home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / vibrant / vibslate.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-17  |  90.5 KB  |  3,471 lines  |  [TEXT/R*ch]
  1. /*   vibslate.c
  2. * ===========================================================================
  3. *
  4. *                            PUBLIC DOMAIN NOTICE
  5. *            National Center for Biotechnology Information (NCBI)
  6. *
  7. *  This software/database is a "United States Government Work" under the
  8. *  terms of the United States Copyright Act.  It was written as part of
  9. *  the author's official duties as a United States Government employee and
  10. *  thus cannot be copyrighted.  This software/database is freely available
  11. *  to the public for use. The National Library of Medicine and the U.S.
  12. *  Government do not place any restriction on its use or reproduction.
  13. *  We would, however, appreciate having the NCBI and the author cited in
  14. *  any work or product based on this material
  15. *
  16. *  Although all reasonable efforts have been taken to ensure the accuracy
  17. *  and reliability of the software and data, the NLM and the U.S.
  18. *  Government do not and cannot warrant the performance or results that
  19. *  may be obtained by using this software or data. The NLM and the U.S.
  20. *  Government disclaim all warranties, express or implied, including
  21. *  warranties of performance, merchantability or fitness for any particular
  22. *  purpose.
  23. *
  24. * ===========================================================================
  25. *
  26. * File Name:  vibslate.c
  27. *
  28. * Author:  Jonathan Kans
  29. *
  30. * Version Creation Date:   7/1/91
  31. *
  32. * $Revision: 2.20 $
  33. *
  34. * File Description: 
  35. *       Vibrant slate (universal drawing environment) functions
  36. *
  37. * Modifications:  
  38. * --------------------------------------------------------------------------
  39. * Date     Name        Description of modification
  40. * -------  ----------  -----------------------------------------------------
  41. *
  42. *
  43. * ==========================================================================
  44. */
  45.  
  46. #include <vibtypes.h>
  47. #include <vibprocs.h>
  48. #include <vibincld.h>
  49.  
  50. #ifdef WIN_MAC
  51. #define Nlm_SlateTool Nlm_Handle
  52. #endif
  53.  
  54. #ifdef WIN_MSWIN
  55. #define Nlm_SlateTool HWND
  56. #endif
  57.  
  58. #ifdef WIN_MOTIF
  59. #define Nlm_SlateTool Widget
  60. #endif
  61.  
  62. typedef  struct  Nlm_slatedata {
  63.   Nlm_SlateTool    handle;
  64.   Nlm_BaR          vScrollBar;
  65.   Nlm_BaR          hScrollBar;
  66.   Nlm_Handle       rowHandles;
  67.   Nlm_Handle       colHandles;
  68.   Nlm_Int2         numRows;
  69.   Nlm_Int2         numCols;
  70.   Nlm_Boolean      border;
  71.   Nlm_Int2         barRows;
  72.   Nlm_Int2         vBefore;
  73.   Nlm_Int2         vAfter;
  74.   Nlm_SltScrlProc  vAction;
  75.   Nlm_SltCharProc  keyProc;
  76.   Nlm_Boolean      hasFocus;
  77. } Nlm_SlateData;
  78.  
  79. typedef  struct  Nlm_paneldata {
  80.   Nlm_PnlClckProc  click;
  81.   Nlm_PnlClckProc  drag;
  82.   Nlm_PnlClckProc  hold;
  83.   Nlm_PnlClckProc  release;
  84.   Nlm_PnlActnProc  draw;
  85.   Nlm_Int2         extra;
  86.   Nlm_PnlActnProc  reset;
  87.   Nlm_PaneL        prev;
  88. } Nlm_PanelData;
  89.  
  90. /* 
  91. *  Panel data is on top of a slate record to allow simple and
  92. *  autonomous panels (such as repeat buttons) to be implemented
  93. *  as single entities.
  94. */
  95.  
  96. typedef  struct  Nlm_panelslaterec {
  97.   Nlm_BoxRec     boxR;
  98.   Nlm_SlateData  slate;
  99.   Nlm_PanelData  panel;
  100. } Nlm_PanelRec, Nlm_SlateRec, PNTR Nlm_PnlPtr, PNTR Nlm_SltPtr;
  101.  
  102. typedef  struct  Nlm_offsetrec {
  103.   Nlm_Int2  offset;
  104.   Nlm_Int2  height;
  105. } Nlm_OffsetRec, PNTR Nlm_OfsPtr;
  106.  
  107. typedef struct Nlm_displaydata {
  108.   Nlm_Boolean  active;
  109.   Nlm_Boolean  changed;
  110.   Nlm_VoidPtr  buffer;
  111.   Nlm_Int2     offset;
  112.   Nlm_Int2     visLines;
  113.   Nlm_PoinT    cursorPos;
  114. } Nlm_DisplayData;
  115.  
  116. typedef struct Nlm_displayrec {
  117.   Nlm_PanelRec     panelR;
  118.   Nlm_DisplayData  display;
  119. } Nlm_DisplayRec, PNTR Nlm_DspPtr;
  120.  
  121. #define screenBufSize 100
  122.  
  123. static Nlm_GphPrcsPtr   gphprcsptr = NULL;
  124.  
  125. static Nlm_GphPrcsPtr   slateProcs;
  126. static Nlm_GphPrcsPtr   panelProcs;
  127. static Nlm_GphPrcsPtr   displayProcs;
  128.  
  129. static Nlm_SlatE        currentSlate = NULL;
  130.  
  131. static Nlm_SlatE        recentSlate = NULL;
  132. static Nlm_SlateData    recentSlateData;
  133.  
  134. static Nlm_SlatE        recentlyClickedSlate = NULL;
  135. static Nlm_Int4         lastClickTime = 0;
  136.  
  137. static Nlm_PaneL        recentlyClickedPanel = NULL;
  138.  
  139. static Nlm_DisplaY      recentDisplay = NULL;
  140. static Nlm_DisplayData  recentDisplayData;
  141.  
  142. static Nlm_Uint2        charCount;
  143. static Nlm_Uint2        screenPos;
  144. static Nlm_Char         screenBfr [screenBufSize];
  145.  
  146. static Nlm_Int2         disphght;
  147. static Nlm_FonT         dispfont;
  148.  
  149. #ifdef WIN_MSWIN
  150. static Nlm_Char         slateclass [32];
  151. static Nlm_Boolean      handlechar;
  152. static Nlm_SlateTool    slateTimer;
  153. static Nlm_Boolean      slateTimerUsed = FALSE;
  154. #endif
  155.  
  156. #ifdef WIN_MOTIF
  157. static XtIntervalId     slateTimer;
  158. static Nlm_Boolean      slateTimerUsed = FALSE;
  159. static Nlm_PoinT        currentMousePos;
  160. #endif
  161.  
  162. static void Nlm_LoadSlateData (Nlm_SlatE s, Nlm_SlateTool hdl,
  163.                                Nlm_BaR vsb, Nlm_BaR hsb,
  164.                                Nlm_Handle rhdl, Nlm_Handle chdl,
  165.                                Nlm_Int2 nrws, Nlm_Int2 ncls,
  166.                                Nlm_Boolean bdr, Nlm_Int2 barrws,
  167.                                Nlm_Int2 vbfr, Nlm_Int2 vaftr,
  168.                                Nlm_SltScrlProc vact, Nlm_SltCharProc key,
  169.                                Nlm_Boolean fcs)
  170.  
  171. {
  172.   Nlm_SltPtr     sp;
  173.   Nlm_SlateData  PNTR sptr;
  174.  
  175.   if (s != NULL) {
  176.     sp = (Nlm_SltPtr) Nlm_HandLock (s);
  177.     sptr = &(sp->slate);
  178.     sptr->handle = hdl;
  179.     sptr->vScrollBar = vsb;
  180.     sptr->hScrollBar = hsb;
  181.     sptr->rowHandles = rhdl;
  182.     sptr->colHandles = chdl;
  183.     sptr->numRows = nrws;
  184.     sptr->numCols = ncls;
  185.     sptr->border = bdr;
  186.     sptr->barRows = barrws;
  187.     sptr->vBefore = vbfr;
  188.     sptr->vAfter = vaftr;
  189.     sptr->vAction = vact;
  190.     sptr->keyProc = key;
  191.     sptr->hasFocus = fcs;
  192.     Nlm_HandUnlock (s);
  193.     recentSlate = NULL;
  194.   }
  195. }
  196.  
  197. static void Nlm_SetSlateData (Nlm_SlatE s, Nlm_SlateData * sdata)
  198.  
  199. {
  200.   Nlm_SltPtr  sp;
  201.  
  202.   if (s != NULL && sdata != NULL) {
  203.     sp = (Nlm_SltPtr) Nlm_HandLock (s);
  204.     sp->slate = *sdata;
  205.     Nlm_HandUnlock (s);
  206.     recentSlate = s;
  207.     recentSlateData = *sdata;
  208.   }
  209. }
  210.  
  211. static void Nlm_GetSlateData (Nlm_SlatE s, Nlm_SlateData * sdata)
  212.  
  213. {
  214.   Nlm_SltPtr  sp;
  215.  
  216.   if (s != NULL && sdata != NULL) {
  217.     if (s == recentSlate && NLM_RISKY) {
  218.       *sdata = recentSlateData;
  219.     } else {
  220.       sp = (Nlm_SltPtr) Nlm_HandLock (s);
  221.       *sdata = sp->slate;
  222.       Nlm_HandUnlock (s);
  223.       recentSlate = s;
  224.       recentSlateData = *sdata;
  225.     }
  226.   }
  227. }
  228.  
  229. static void Nlm_LoadPanelData (Nlm_PaneL p, Nlm_PnlClckProc clk,
  230.                                Nlm_PnlClckProc drg, Nlm_PnlClckProc hld,
  231.                                Nlm_PnlClckProc rls, Nlm_PnlActnProc drw,
  232.                                Nlm_Int2 xtra, Nlm_PnlActnProc rst,
  233.                                Nlm_PaneL prv)
  234.  
  235. {
  236.   Nlm_PnlPtr     pp;
  237.   Nlm_PanelData  PNTR pptr;
  238.  
  239.   if (p != NULL) {
  240.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  241.     pptr = &(pp->panel);
  242.     pptr->click = clk;
  243.     pptr->drag = drg;
  244.     pptr->hold = hld;
  245.     pptr->release = rls;
  246.     pptr->draw = drw;
  247.     pptr->extra = xtra;
  248.     pptr->reset = rst;
  249.     pptr->prev = prv;
  250.     Nlm_HandUnlock (p);
  251.   }
  252. }
  253.  
  254. #ifdef DCLAP
  255. extern void Nlm_ClearPanelData (Nlm_PaneL p)
  256. {
  257.     /* clean out panel pointers so damn Xwindow callbacks stop calling dead subviews 
  258.         for draw updates in dead windows @! */
  259.   Nlm_PnlPtr     pp;
  260.   Nlm_PanelData  PNTR pptr;
  261.   if (p != NULL) {
  262.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  263.     pptr = &(pp->panel);
  264.     pptr->click = NULL;
  265.     pptr->drag = NULL;
  266.     pptr->hold = NULL;
  267.     pptr->release = NULL;
  268.     pptr->draw = NULL;
  269.     pptr->extra = 0; /*NULL; -- dgg */
  270.     pptr->reset = NULL;
  271.     pptr->prev = NULL;
  272.     Nlm_HandUnlock (p);
  273.   }
  274. }
  275.  
  276. #endif
  277.  
  278. static void Nlm_SetPanelData (Nlm_PaneL p, Nlm_PanelData * pdata)
  279.  
  280. {
  281.   Nlm_PnlPtr  pp;
  282.  
  283.   if (p != NULL && pdata != NULL) {
  284.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  285.     pp->panel = *pdata;
  286.     Nlm_HandUnlock (p);
  287.   }
  288. }
  289.  
  290. static void Nlm_GetPanelData (Nlm_PaneL p, Nlm_PanelData * pdata)
  291.  
  292. {
  293.   Nlm_PnlPtr  pp;
  294.  
  295.   if (p != NULL && pdata != NULL) {
  296.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  297.     *pdata = pp->panel;
  298.     Nlm_HandUnlock (p);
  299.   }
  300. }
  301.  
  302. static void Nlm_LoadDisplayData (Nlm_DisplaY d, Nlm_Boolean actv,
  303.                                  Nlm_Boolean chgd, Nlm_VoidPtr bufr,
  304.                                  Nlm_Int2 off, Nlm_Int2 vis,
  305.                                  Nlm_PoinT pos)
  306.  
  307. {
  308.   Nlm_DisplayData  PNTR ddptr;
  309.   Nlm_DspPtr       dp;
  310.  
  311.   if (d != NULL) {
  312.     dp = (Nlm_DspPtr) Nlm_HandLock (d);
  313.     ddptr = &(dp->display);
  314.     ddptr->active = actv;
  315.     ddptr->changed = chgd;
  316.     ddptr->buffer = bufr;
  317.     ddptr->offset = off;
  318.     ddptr->visLines = vis;
  319.     ddptr->cursorPos = pos;
  320.     Nlm_HandUnlock (d);
  321.     recentDisplay = NULL;
  322.   }
  323. }
  324.  
  325. static void Nlm_SetDisplayData (Nlm_DisplaY d, Nlm_DisplayData * ddata)
  326.  
  327. {
  328.   Nlm_DspPtr  dp;
  329.  
  330.   if (d != NULL && ddata != NULL) {
  331.     dp = (Nlm_DspPtr) Nlm_HandLock (d);
  332.     dp->display = *ddata;
  333.     Nlm_HandUnlock (d);
  334.     recentDisplay = d;
  335.     recentDisplayData = *ddata;
  336.   }
  337. }
  338.  
  339. static void Nlm_GetDisplayData (Nlm_DisplaY d, Nlm_DisplayData * ddata)
  340.  
  341. {
  342.   Nlm_DspPtr  dp;
  343.  
  344.   if (d != NULL && ddata != NULL) {
  345.     if (d == recentDisplay && NLM_RISKY) {
  346.       *ddata = recentDisplayData;
  347.     } else {
  348.       dp = (Nlm_DspPtr) Nlm_HandLock (d);
  349.       *ddata = dp->display;
  350.       Nlm_HandUnlock (d);
  351.       recentDisplay = d;
  352.       recentDisplayData = *ddata;
  353.     }
  354.   }
  355. }
  356.  
  357. extern void Nlm_SetPanelExtra (Nlm_PaneL p, Nlm_VoidPtr sptr)
  358.  
  359. {
  360.   Nlm_BytePtr  dst;
  361.   Nlm_Int2     extra;
  362.   Nlm_PnlPtr   pp;
  363.   Nlm_BytePtr  src;
  364.  
  365.   if (p != NULL && sptr != NULL) {
  366.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  367.     extra = pp->panel.extra;
  368.     dst = (Nlm_BytePtr) pp + sizeof (Nlm_PanelRec);
  369.     src = (Nlm_BytePtr) sptr;
  370.     while (extra > 0) {
  371.       *dst = *src;
  372.       dst++;
  373.       src++;
  374.       extra--;
  375.     }
  376.     Nlm_HandUnlock (p);
  377.   }
  378. }
  379.  
  380. extern void Nlm_GetPanelExtra (Nlm_PaneL p, Nlm_VoidPtr sptr)
  381.  
  382. {
  383.   Nlm_BytePtr  dst;
  384.   Nlm_Int2     extra;
  385.   Nlm_PnlPtr   pp;
  386.   Nlm_BytePtr  src;
  387.  
  388.   if (p != NULL && sptr != NULL) {
  389.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  390.     extra = pp->panel.extra;
  391.     src = (Nlm_BytePtr) pp + sizeof (Nlm_PanelRec);
  392.     dst = (Nlm_BytePtr) sptr;
  393.     while (extra > 0) {
  394.       *dst = *src;
  395.       dst++;
  396.       src++;
  397.       extra--;
  398.     }
  399.     Nlm_HandUnlock (p);
  400.   }
  401. }
  402.  
  403. static Nlm_SlateTool Nlm_GetSlateHandle (Nlm_SlatE s)
  404.  
  405. {
  406.   Nlm_SlateData  sdata;
  407.  
  408.   Nlm_GetSlateData (s, &sdata);
  409.   return sdata.handle;
  410. }
  411.  
  412. extern Nlm_BaR Nlm_GetSlateVScrollBar (Nlm_SlatE s)
  413.  
  414. {
  415.   Nlm_SlateData  sdata;
  416.  
  417.   Nlm_GetSlateData (s, &sdata);
  418.   return sdata.vScrollBar;
  419. }
  420.  
  421. extern Nlm_BaR Nlm_GetSlateHScrollBar (Nlm_SlatE s)
  422.  
  423. {
  424.   Nlm_SlateData  sdata;
  425.  
  426.   Nlm_GetSlateData (s, &sdata);
  427.   return sdata.hScrollBar;
  428. }
  429.  
  430. static Nlm_Handle Nlm_GetSlateRowHandles (Nlm_SlatE s)
  431.  
  432. {
  433.   Nlm_SlateData  sdata;
  434.  
  435.   Nlm_GetSlateData (s, &sdata);
  436.   return sdata.rowHandles;
  437. }
  438.  
  439. static Nlm_Handle Nlm_GetSlateColHandles (Nlm_SlatE s)
  440.  
  441. {
  442.   Nlm_SlateData  sdata;
  443.  
  444.   Nlm_GetSlateData (s, &sdata);
  445.   return sdata.colHandles;
  446. }
  447.  
  448. static Nlm_Int2 Nlm_GetSlateNumRows (Nlm_SlatE s)
  449.  
  450. {
  451.   Nlm_SlateData  sdata;
  452.  
  453.   Nlm_GetSlateData (s, &sdata);
  454.   return sdata.numRows;
  455. }
  456.  
  457. static Nlm_Int2 Nlm_GetSlateNumCols (Nlm_SlatE s)
  458.  
  459. {
  460.   Nlm_SlateData  sdata;
  461.  
  462.   Nlm_GetSlateData (s, &sdata);
  463.   return sdata.numCols;
  464. }
  465.  
  466. static Nlm_Boolean Nlm_GetSlateBorder (Nlm_SlatE s)
  467.  
  468. {
  469.   Nlm_SlateData  sdata;
  470.  
  471.   Nlm_GetSlateData (s, &sdata);
  472.   return sdata.border;
  473. }
  474.  
  475. /* dgg -- fix for content drawing erasing border frame */
  476. static void Nlm_DrawSlateBorder (Nlm_SlatE s)
  477. {
  478.     Nlm_RecT     r;
  479.   if (Nlm_GetSlateBorder( s)) {
  480.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  481.       Nlm_InsetRect( &r, -1, -1); /* needs an outset so content draw dosn't wipe it out */
  482.     Nlm_FrameRect (&r);
  483.     }
  484. }
  485.  
  486. /* dgg -- lets turn off that border sometimes */
  487.  
  488. extern void Nlm_SetSlateBorder (Nlm_SlatE s, Nlm_Boolean turnon)
  489.  
  490. {
  491.   Nlm_SlateData  sdata;
  492.  
  493.   Nlm_GetSlateData (s, &sdata);
  494.   sdata.border = turnon;
  495.   Nlm_SetSlateData (s, &sdata);
  496. }
  497.  
  498. static Nlm_SltCharProc Nlm_GetSlateCharProc (Nlm_SlatE s)
  499.  
  500. {
  501.   Nlm_SlateData  sdata;
  502.  
  503.   Nlm_GetSlateData (s, &sdata);
  504.   return sdata.keyProc;
  505. }
  506.  
  507. extern void Nlm_SetSlateChar (Nlm_SlatE s, Nlm_SltCharProc chr)
  508.  
  509. {
  510.   Nlm_SlateData  sdata;
  511.  
  512.   Nlm_GetSlateData (s, &sdata);
  513.   sdata.keyProc = chr;
  514.   Nlm_SetSlateData (s, &sdata);
  515. }
  516.  
  517. static Nlm_Boolean Nlm_SlateHasFocus (Nlm_SlatE s)
  518.  
  519. {
  520.   Nlm_SlateData  sdata;
  521.  
  522.   Nlm_GetSlateData (s, &sdata);
  523.   return sdata.hasFocus;
  524. }
  525.  
  526. static void Nlm_ChangeSlateFocus (Nlm_SlatE s, Nlm_Boolean fcs)
  527.  
  528. {
  529.   Nlm_SlateData  sdata;
  530.  
  531.   Nlm_GetSlateData (s, &sdata);
  532.   sdata.hasFocus = fcs;
  533.   Nlm_SetSlateData (s, &sdata);
  534. }
  535.  
  536. static Nlm_PnlClckProc Nlm_GetPanelClick (Nlm_PaneL p)
  537.  
  538. {
  539.   Nlm_PanelData  pdata;
  540.  
  541.   Nlm_GetPanelData (p, &pdata);
  542.   return pdata.click;
  543. }
  544.  
  545. static Nlm_PnlClckProc Nlm_GetPanelDrag (Nlm_PaneL p)
  546.  
  547. {
  548.   Nlm_PanelData  pdata;
  549.  
  550.   Nlm_GetPanelData (p, &pdata);
  551.   return pdata.drag;
  552. }
  553.  
  554. static Nlm_PnlClckProc Nlm_GetPanelHold (Nlm_PaneL p)
  555.  
  556. {
  557.   Nlm_PanelData  pdata;
  558.  
  559.   Nlm_GetPanelData (p, &pdata);
  560.   return pdata.hold;
  561. }
  562.  
  563. static Nlm_PnlClckProc Nlm_GetPanelRelease (Nlm_PaneL p)
  564.  
  565. {
  566.   Nlm_PanelData  pdata;
  567.  
  568.   Nlm_GetPanelData (p, &pdata);
  569.   return pdata.release;
  570. }
  571.  
  572. static Nlm_PnlActnProc Nlm_GetPanelDraw (Nlm_PaneL p)
  573.  
  574. {
  575.   Nlm_PanelData  pdata;
  576.  
  577.   Nlm_GetPanelData (p, &pdata);
  578.   return pdata.draw;
  579. }
  580.  
  581. static void Nlm_SetPanelPrev (Nlm_PaneL p, Nlm_PaneL prv)
  582.  
  583. {
  584.   Nlm_PanelData  pdata;
  585.  
  586.   Nlm_GetPanelData (p, &pdata);
  587.   pdata.prev = prv;
  588.   Nlm_SetPanelData (p, &pdata);
  589. }
  590.  
  591. static Nlm_PaneL Nlm_GetPanelPrev (Nlm_PaneL p)
  592.  
  593. {
  594.   Nlm_PanelData  pdata;
  595.  
  596.   Nlm_GetPanelData (p, &pdata);
  597.   return pdata.prev;
  598. }
  599.  
  600. static Nlm_Int2 Nlm_GetDisplayVisLines (Nlm_DisplaY d)
  601.  
  602. {
  603.   Nlm_DisplayData  ddata;
  604.  
  605.   Nlm_GetDisplayData (d, &ddata);
  606.   return ddata.visLines;
  607. }
  608.  
  609. static void Nlm_SetCursorPos (Nlm_DisplaY d, Nlm_PoinT pt)
  610.  
  611. {
  612.   Nlm_DisplayData  ddata;
  613.  
  614.   Nlm_GetDisplayData (d, &ddata);
  615.   ddata.cursorPos = pt;
  616.   Nlm_SetDisplayData (d, &ddata);
  617. }
  618.  
  619. static void Nlm_GetCursorPos (Nlm_DisplaY d, Nlm_PointPtr pt)
  620.  
  621. {
  622.   Nlm_DisplayData  ddata;
  623.  
  624.   Nlm_GetDisplayData (d, &ddata);
  625.   *pt = ddata.cursorPos;
  626. }
  627.  
  628. static Nlm_PaneL Nlm_CreateReverseLinks (Nlm_SlatE s)
  629.  
  630. {
  631.   Nlm_PaneL  last;
  632.   Nlm_PaneL  n;
  633.   Nlm_PaneL  p;
  634.  
  635.   p = (Nlm_PaneL) Nlm_GetChild ((Nlm_GraphiC) s);
  636.   Nlm_SetPanelPrev (p, NULL);
  637.   last = p;
  638.   while (p != NULL) {
  639.     n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  640.     if (n != NULL) {
  641.       Nlm_SetPanelPrev (n, p);
  642.       last = n;
  643.     }
  644.     p = n;
  645.   }
  646.   return last;
  647. }
  648.  
  649. #ifdef WIN_MAC
  650. static Nlm_Boolean Nlm_SlateClick (Nlm_GraphiC s, Nlm_PoinT pt)
  651.  
  652. {
  653.   Nlm_PnlClckProc  clk;
  654.   Nlm_Int4         delta;
  655.   Nlm_PnlClckProc  drg;
  656.   Nlm_Int2         hOffset;
  657.   Nlm_BaR          hsb;
  658.   Nlm_PoinT        mpt;
  659.   Nlm_PaneL        n;
  660.   Nlm_Int4         newtime;
  661.   Nlm_Boolean      notInside;
  662.   Nlm_Int4         oldtime;
  663.   Nlm_PoinT        opt;
  664.   Nlm_PaneL        p;
  665.   Nlm_PanelData    pdata;
  666.   Nlm_PnlClckProc  prs;
  667.   Nlm_RecT         r;
  668.   Nlm_PnlClckProc  rls;
  669.   Nlm_Boolean      rsult;
  670.   Nlm_RecT         sr;
  671.   Nlm_Int4         ticks;
  672.   Nlm_Int2         vOffset;
  673.   Nlm_BaR          vsb;
  674.  
  675.   ticks = Nlm_ComputerTime ();
  676.   rsult = FALSE;
  677.   Nlm_GetRect (s, &r);
  678.   Nlm_GetRect (s, &sr);
  679.   vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  680.   hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  681.   if (vsb != NULL) {
  682.     r.right += Nlm_vScrollBarWidth;
  683.   }
  684.   if (hsb != NULL) {
  685.     r.bottom += Nlm_hScrollBarHeight;
  686.   }
  687.   if (Nlm_PtInRect (pt, &r)) {
  688.     if ((Nlm_SlatE) s == recentlyClickedSlate) {
  689.       delta = ticks - lastClickTime;
  690.       if (delta <= GetDblTime ()) {
  691.         Nlm_dblClick = TRUE;
  692.       }
  693.     }
  694.     lastClickTime = ticks;
  695.     recentlyClickedSlate = (Nlm_SlatE) s;
  696.     recentlyClickedPanel = NULL;
  697.     if (vsb != NULL) {
  698.       r.right -= Nlm_vScrollBarWidth;
  699.     }
  700.     if (hsb != NULL) {
  701.       r.bottom -= Nlm_hScrollBarHeight;
  702.     }
  703.     if (vsb != NULL && Nlm_DoClick ((Nlm_GraphiC) vsb, pt)) {
  704.       Nlm_dblClick = FALSE;
  705.       recentlyClickedSlate = NULL;
  706.     } else if (hsb != NULL && Nlm_DoClick ((Nlm_GraphiC) hsb, pt)) {
  707.       Nlm_dblClick = FALSE;
  708.       recentlyClickedSlate = NULL;
  709.     } else if (Nlm_PtInRect (pt, &r)) {
  710.       Nlm_SelectFont (Nlm_systemFont);
  711.       Nlm_ResetDrawingTools ();
  712.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  713.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  714.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  715.         p = (Nlm_PaneL) s;
  716.         recentlyClickedPanel = p;
  717.         clk = Nlm_GetPanelClick (p);
  718.         if (clk != NULL && Nlm_GetEnabled ((Nlm_GraphiC) p) && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  719.           Nlm_ClipRect (&sr);
  720.           clk (p, pt);
  721.           Nlm_Update ();
  722.         }
  723.       } else {
  724.         p = Nlm_CreateReverseLinks ((Nlm_SlatE) s);
  725.         notInside = TRUE;
  726.         while (p != NULL && notInside) {
  727.           n = Nlm_GetPanelPrev (p);
  728.           Nlm_GetPanelData (p, &pdata);
  729.           if (pdata.click != NULL || pdata.drag != NULL ||
  730.               pdata.hold != NULL || pdata.release != NULL) {
  731.             Nlm_GetRect ((Nlm_GraphiC) p, &r);
  732.             Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  733.             Nlm_OffsetRect (&r, -hOffset, -vOffset);
  734.             if (Nlm_PtInRect (pt, &r) && Nlm_GetEnabled ((Nlm_GraphiC) p) &&
  735.                 Nlm_GetVisible ((Nlm_GraphiC) p)) {
  736.               recentlyClickedPanel = p;
  737.               notInside = FALSE;
  738.               clk = Nlm_GetPanelClick (p);
  739.               if (clk != NULL) {
  740.                 Nlm_ClipRect (&sr);
  741.                 clk (p, pt);
  742.                 Nlm_Update ();
  743.               }
  744.             }
  745.           }
  746.           p = n;
  747.         }
  748.       }
  749.       if (recentlyClickedPanel != NULL) {
  750.         p = recentlyClickedPanel;
  751.         mpt = pt;
  752.         oldtime = Nlm_ComputerTime ();
  753.         drg = Nlm_GetPanelDrag (p);
  754.         prs = Nlm_GetPanelHold (p);
  755.         while (StillDown () && recentlyClickedPanel != NULL) {
  756.           opt = mpt;
  757.           newtime = Nlm_ComputerTime ();
  758.           Nlm_MousePosition (&mpt);
  759.           if (Nlm_EqualPt (opt, mpt)) {
  760.             if (prs != NULL && newtime >= oldtime + 6) {
  761.               Nlm_ResetDrawingTools ();
  762.               Nlm_ClipRect (&sr);
  763.               prs (p, mpt);
  764.               oldtime += 6;
  765.             }
  766.           } else {
  767.             if (drg != NULL) {
  768.               Nlm_ResetDrawingTools ();
  769.               Nlm_ClipRect (&sr);
  770.               drg (p, mpt);
  771.             }
  772.           }
  773.           Nlm_Update ();
  774.           Nlm_ProcessTimerEvent ();
  775.         }
  776.         rls = Nlm_GetPanelRelease (p);
  777.         if (rls != NULL && recentlyClickedPanel != NULL) {
  778.           Nlm_MousePosition (&mpt);
  779.           Nlm_ResetDrawingTools ();
  780.           Nlm_ClipRect (&sr);
  781.           rls (p, mpt);
  782.         }
  783.       }
  784.       Nlm_SelectFont (Nlm_systemFont);
  785.       Nlm_ResetDrawingTools ();
  786.       Nlm_ResetClip ();
  787.       rsult = TRUE;
  788.     }
  789.   }
  790.   return rsult;
  791. }
  792.  
  793. static Nlm_Boolean Nlm_SlateKey (Nlm_GraphiC s, Nlm_Char ch)
  794.  
  795. {
  796.   Nlm_Boolean      act;
  797.   Nlm_SltCharProc  keyProc;
  798.   Nlm_Boolean      rsult;
  799.  
  800.   rsult = FALSE;
  801.   act = Nlm_SlateHasFocus ((Nlm_SlatE) s);
  802.   if (act && ! Nlm_cmmdKey) {
  803.     if (ch != '\0') {
  804.       keyProc = Nlm_GetSlateCharProc ((Nlm_SlatE) s);
  805.       if (keyProc != NULL) {
  806.         keyProc ((Nlm_SlatE) s, ch);
  807.         rsult = TRUE;
  808.       }
  809.     }
  810.   }
  811.   return rsult;
  812. }
  813. #endif
  814.  
  815. #ifdef WIN_MSWIN
  816. static Nlm_Boolean Nlm_SlateCommand (Nlm_GraphiC s)
  817.  
  818. {
  819.   return FALSE;
  820. }
  821. #endif
  822.  
  823. #ifdef WIN_MOTIF
  824. static void Nlm_SlateCallback (Nlm_GraphiC s)
  825.  
  826. {
  827. }
  828. #endif
  829.  
  830. #ifdef WIN_MAC
  831. static void Nlm_DrawSlate (Nlm_GraphiC s)
  832.  
  833. {
  834.   Nlm_PnlActnProc  drw;
  835.   Nlm_BaR          hsb;
  836.   Nlm_PaneL        n;
  837.   Nlm_PaneL        p;
  838.   Nlm_PanelData    pdata;
  839.   Nlm_RecT         r;
  840.   Nlm_BaR          vsb;
  841.  
  842.   if (Nlm_GetVisible (s) && Nlm_GetAllParentsVisible (s)) {
  843.     Nlm_GetRect (s, &r);
  844.     vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  845.     hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  846.     if (vsb != NULL) {
  847.       r.right += Nlm_vScrollBarWidth;
  848.     }
  849.     if (hsb != NULL) {
  850.       r.bottom += Nlm_hScrollBarHeight;
  851.     }
  852.     if (Nlm_RectInRgn (&r, Nlm_updateRgn)) {
  853.       if (vsb != NULL) {
  854.         Nlm_DoDraw ((Nlm_GraphiC) vsb);
  855.       }
  856.       if (hsb != NULL) {
  857.         Nlm_DoDraw ((Nlm_GraphiC) hsb);
  858.       }
  859.       Nlm_SelectFont (Nlm_systemFont);
  860.       Nlm_ResetDrawingTools ();
  861.             Nlm_DrawSlateBorder( (Nlm_SlatE) s);
  862.       Nlm_GetRect (s, &r);
  863.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  864.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  865.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  866.         p = (Nlm_PaneL) s;
  867. /*
  868.         recentlyClickedPanel = p;
  869. */
  870.         drw = Nlm_GetPanelDraw (p);
  871.         if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  872.           Nlm_ClipRect (&r);
  873.           drw (p);
  874.           Nlm_ResetDrawingTools ();
  875.         }
  876.       } else {
  877.         p = (Nlm_PaneL) Nlm_GetChild (s);
  878.         while (p != NULL) {
  879.           n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  880.           drw = Nlm_GetPanelDraw (p);
  881.           if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  882.             Nlm_ClipRect (&r);
  883.             drw (p);
  884.             Nlm_ResetDrawingTools ();
  885.           }
  886.           p = n;
  887.         }
  888.       }
  889.       Nlm_ResetClip ();
  890.     }
  891.   }
  892. }
  893. #endif
  894.  
  895. static void Nlm_SlateVertScrollAction (Nlm_BaR sb, Nlm_SlatE s,
  896.                                        Nlm_Int2 newval, Nlm_Int2 oldval)
  897.  
  898. {
  899.   Nlm_SltScrlProc  actn;
  900.   Nlm_Int2         barRows;
  901.   Nlm_Int2         before;
  902.   Nlm_Int2         delta;
  903.   Nlm_Int2         height;
  904.   Nlm_Int2         i;
  905.   Nlm_Int2         last;
  906.   Nlm_Int2         limit;
  907.   Nlm_Int2         numRows;
  908.   Nlm_Int2         oldPgDn;
  909.   Nlm_OfsPtr       optr;
  910.   Nlm_Int2         pgDn;
  911.   Nlm_Int2         pgUp;
  912.   Nlm_RecT         r;
  913.   Nlm_Handle       rhdl;
  914.   Nlm_SlateData    sdata;
  915.  
  916.   if (s != NULL && oldval != newval) {
  917.     if (Nlm_GetVisible ((Nlm_GraphiC) s) && Nlm_GetAllParentsVisible ((Nlm_GraphiC) s)) {
  918.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  919. #ifdef DCLAP
  920.            Nlm_InsetRect (&r, 1, 1);
  921.                 /* dgg -- why this 4pt inset?? it leaves other drawn contents hanging messy */
  922. #else
  923.       Nlm_InsetRect (&r, 4, 4);
  924. #endif
  925.       height = r.bottom - r.top;
  926.       Nlm_GetSlateData (s, &sdata);
  927.       numRows = sdata.numRows;
  928.       before = sdata.vBefore;
  929.       barRows = sdata.barRows;
  930.       if (newval >= before && newval <= before + barRows) {
  931.         newval -= before;
  932.         oldval -= before;
  933.         rhdl = sdata.rowHandles;
  934.         if (rhdl != NULL) {
  935.           optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  936.           i = newval + 1;
  937.           pgDn = 0;
  938.           while (i < numRows && optr [i].offset + optr [i].height -
  939.                  optr [newval].offset <= height) {
  940.             i++;
  941.             pgDn++;
  942.           }
  943.           i = newval - 1;
  944.           pgUp = 0;
  945.           while (i >= 0 && optr [newval].offset + optr [newval].height -
  946.                  optr [i].offset <= height) {
  947.             i--;
  948.             pgUp++;
  949.           }
  950.           delta = optr [oldval].offset - optr [newval].offset;
  951.           if (delta < 0) {
  952.             i = oldval + 1;
  953.             oldPgDn = 0;
  954.             while (i < numRows && optr [i].offset + optr [i].height -
  955.                    optr [oldval].offset <= height) {
  956.               i++;
  957.               oldPgDn++;
  958.             }
  959.             last = oldval + oldPgDn;
  960.             limit = r.top + optr [last].offset + optr [last].height  - optr [newval].offset;
  961.           } else if (delta > 0) {
  962.             last = newval + pgDn;
  963.             limit = r.top + optr [last].offset + optr [last].height  - optr [newval].offset;
  964.           }
  965.           Nlm_HandUnlock (rhdl);
  966.           Nlm_DoSelect ((Nlm_GraphiC) s, FALSE);
  967.           if (delta < 0 && -delta < height) {
  968.             Nlm_ScrollRect (&r, 0, delta);
  969.             r.top = limit;
  970.             Nlm_InsetRect (&r, -1, -1);
  971.             Nlm_InvalRect (&r);
  972.           } else if (delta > 0 && delta < height) {
  973.             Nlm_ScrollRect (&r, 0, delta);
  974.             r.top = limit;
  975.             Nlm_InsetRect (&r, -1, -1);
  976.             Nlm_InvalRect (&r);
  977.           } else {
  978.             Nlm_InsetRect (&r, -1, -1);
  979.             Nlm_InvalRect (&r);
  980.           }
  981.           if (pgUp < 1) {
  982.             pgUp = 1;
  983.           }
  984.           if (pgDn < 1) {
  985.             pgDn = 1;
  986.           }
  987.           Nlm_DoSetRange ((Nlm_GraphiC) sb, pgUp, pgDn, 0, FALSE);
  988.           Nlm_Update ();
  989.         }
  990.       } else {
  991.         actn = sdata.vAction;
  992.         if (actn != NULL) {
  993.           actn (sb, s, newval, oldval);
  994.         }
  995.       }
  996.     }
  997.   }
  998. }
  999.  
  1000. static void Nlm_SlateHorizScrollAction (Nlm_BaR sb, Nlm_SlatE s,
  1001.                                         Nlm_Int2 newval, Nlm_Int2 oldval)
  1002.  
  1003. {
  1004. }
  1005.  
  1006. static void Nlm_ShowSlate (Nlm_GraphiC s, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1007.  
  1008. {
  1009.   Nlm_SlateTool  h;
  1010.   Nlm_BaR        hsb;
  1011.   Nlm_WindoW     tempPort;
  1012.   Nlm_BaR        vsb;
  1013.  
  1014.   if (setFlag) {
  1015.     Nlm_SetVisible (s, TRUE);
  1016.   }
  1017.   if (Nlm_GetVisible (s) && Nlm_AllParentsButWindowVisible (s)) {
  1018.     tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1019.     vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1020.     hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1021.     if (vsb != NULL) {
  1022.       Nlm_DoShow ((Nlm_GraphiC) vsb, TRUE, FALSE);
  1023.     }
  1024.     if (hsb != NULL) {
  1025.       Nlm_DoShow ((Nlm_GraphiC) hsb, TRUE, FALSE);
  1026.     }
  1027.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1028. #ifdef WIN_MAC
  1029.     Nlm_DoDraw (s);
  1030. #endif
  1031. #ifdef WIN_MSWIN
  1032.     ShowWindow (h, SW_SHOW);
  1033.     UpdateWindow (h);
  1034. #endif
  1035. #ifdef WIN_MOTIF
  1036.     XtManageChild (h);
  1037. #endif
  1038.     Nlm_RestorePort (tempPort);
  1039.   }
  1040. }
  1041.  
  1042. static void Nlm_ShowPanel (Nlm_GraphiC p, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1043.  
  1044. {
  1045.   Nlm_RecT    dr;
  1046.   Nlm_Int2    hOffset;
  1047.   Nlm_RecT    r;
  1048.   Nlm_SlatE   s;
  1049.   Nlm_RecT    sr;
  1050.   Nlm_Int2    vOffset;
  1051.   Nlm_WindoW  tempPort;
  1052.  
  1053.   if (setFlag) {
  1054.     Nlm_SetVisible (p, TRUE);
  1055.   }
  1056.   if (Nlm_GetVisible (p) && Nlm_AllParentsButWindowVisible (p)) {
  1057.     tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1058.     Nlm_GetRect (p, &r);
  1059.     Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  1060.     Nlm_OffsetRect (&r, -hOffset, -vOffset);
  1061.     s = (Nlm_SlatE) Nlm_GetParent (p);
  1062.     Nlm_GetRect ((Nlm_GraphiC) s, &sr);
  1063.     Nlm_SectRect (&r, &sr, &dr);
  1064.     if (Nlm_RectInRect (&dr, &sr)) {
  1065.       Nlm_InsetRect (&dr, -1, -1);
  1066.       Nlm_InvalRect (&dr);
  1067.     }
  1068.     Nlm_RestorePort (tempPort);
  1069.   }
  1070. }
  1071.  
  1072. static void Nlm_HideSlate (Nlm_GraphiC s, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1073.  
  1074. {
  1075.   Nlm_SlateTool  h;
  1076.   Nlm_BaR        hsb;
  1077.   Nlm_WindoW     tempPort;
  1078.   Nlm_BaR        vsb;
  1079. #ifdef WIN_MAC
  1080.   Nlm_RecT       r;
  1081. #endif
  1082.  
  1083.   if (setFlag) {
  1084.     Nlm_SetVisible (s, FALSE);
  1085.   }
  1086.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1087.   vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1088.   hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1089.   if (vsb != NULL) {
  1090.     Nlm_DoHide ((Nlm_GraphiC) vsb, TRUE, FALSE);
  1091.   }
  1092.   if (hsb != NULL) {
  1093.     Nlm_DoHide ((Nlm_GraphiC) hsb, TRUE, FALSE);
  1094.   }
  1095.   h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1096. #ifdef WIN_MAC
  1097.   if (Nlm_AllParentsButWindowVisible (s)) {
  1098.     Nlm_GetRect (s, &r);
  1099.     r.right += Nlm_vScrollBarWidth;
  1100.     r.bottom += Nlm_hScrollBarHeight;
  1101.     Nlm_InsetRect (&r, -1, -1);
  1102.     Nlm_EraseRect (&r);
  1103.     Nlm_ValidRect (&r);
  1104.   }
  1105. #endif
  1106. #ifdef WIN_MSWIN
  1107.   ShowWindow (h, SW_HIDE);
  1108.   UpdateWindow (h);
  1109. #endif
  1110. #ifdef WIN_MOTIF
  1111.   XtUnmanageChild (h);
  1112. #endif
  1113.   Nlm_RestorePort (tempPort);
  1114. }
  1115.  
  1116. static void Nlm_HidePanel (Nlm_GraphiC p, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1117.  
  1118. {
  1119.   Nlm_RecT    dr;
  1120.   Nlm_Int2    hOffset;
  1121.   Nlm_RecT    r;
  1122.   Nlm_SlatE   s;
  1123.   Nlm_RecT    sr;
  1124.   Nlm_Int2    vOffset;
  1125.   Nlm_WindoW  tempPort;
  1126.  
  1127.   if (setFlag) {
  1128.     Nlm_SetVisible (p, FALSE);
  1129.   }
  1130.   tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1131.   if (Nlm_AllParentsButWindowVisible (p)) {
  1132.     Nlm_GetRect (p, &r);
  1133.     Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  1134.     Nlm_OffsetRect (&r, -hOffset, -vOffset);
  1135.     s = (Nlm_SlatE) Nlm_GetParent (p);
  1136.     Nlm_GetRect ((Nlm_GraphiC) s, &sr);
  1137.     Nlm_SectRect (&r, &sr, &dr);
  1138.     if (Nlm_RectInRect (&dr, &sr)) {
  1139.       Nlm_InsetRect (&dr, -1, -1);
  1140.       Nlm_InvalRect (&dr);
  1141.     }
  1142.   }
  1143.   Nlm_RestorePort (tempPort);
  1144. }
  1145.  
  1146. static void Nlm_EnableSlate (Nlm_GraphiC s, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1147.  
  1148. {
  1149.   Nlm_SlateTool  h;
  1150.   Nlm_BaR        hsb;
  1151.   Nlm_RecT       r;
  1152.   Nlm_WindoW     tempPort;
  1153.   Nlm_BaR        vsb;
  1154.  
  1155.   if (setFlag) {
  1156.     Nlm_SetEnabled (s, TRUE);
  1157.   }
  1158.   if (Nlm_GetEnabled (s) && Nlm_GetAllParentsEnabled (s)) {
  1159.     tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1160.     vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1161.     hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1162.     if (vsb != NULL) {
  1163.       Nlm_DoEnable ((Nlm_GraphiC) vsb, TRUE, FALSE);
  1164.     }
  1165.     if (hsb != NULL) {
  1166.       Nlm_DoEnable ((Nlm_GraphiC) hsb, TRUE, FALSE);
  1167.     }
  1168.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1169. #ifdef WIN_MSWIN
  1170.     EnableWindow (h, TRUE);
  1171. #endif
  1172. #ifdef WIN_MOTIF
  1173.     /*
  1174.     XtVaSetValues (h, XmNsensitive, TRUE, NULL);
  1175.     */
  1176. #endif
  1177.     if (setFlag) {
  1178.       if (Nlm_GetVisible (s) && Nlm_GetAllParentsVisible (s)) {
  1179.         Nlm_DoSelect ((Nlm_GraphiC) s, FALSE);
  1180.         Nlm_GetRect (s, &r);
  1181.         Nlm_InsetRect (&r, 1, 1);
  1182.         Nlm_InvalRect (&r);
  1183.       }
  1184.     }
  1185.     Nlm_RestorePort (tempPort);
  1186.   }
  1187. }
  1188.  
  1189. static void Nlm_EnablePanel (Nlm_GraphiC p, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1190.  
  1191. {
  1192.   Nlm_SlatE  s;
  1193.  
  1194.   if (setFlag) {
  1195.     Nlm_SetEnabled (p, TRUE);
  1196.   }
  1197.   s = (Nlm_SlatE) Nlm_GetParent (p);
  1198.   Nlm_DoEnable ((Nlm_GraphiC) s, TRUE, savePort);
  1199. }
  1200.  
  1201. static void Nlm_DisableSlate (Nlm_GraphiC s, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1202.  
  1203. {
  1204.   Nlm_SlateTool  h;
  1205.   Nlm_BaR        hsb;
  1206.   Nlm_WindoW     tempPort;
  1207.   Nlm_BaR        vsb;
  1208.  
  1209.   if (setFlag) {
  1210.     Nlm_SetEnabled (s, FALSE);
  1211.   }
  1212.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1213.   vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1214.   hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1215.   if (vsb != NULL) {
  1216.     Nlm_DoDisable ((Nlm_GraphiC) vsb, TRUE, FALSE);
  1217.   }
  1218.   if (hsb != NULL) {
  1219.     Nlm_DoDisable ((Nlm_GraphiC) hsb, TRUE, FALSE);
  1220.   }
  1221.   h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1222. #ifdef WIN_MSWIN
  1223.   EnableWindow (h, FALSE);
  1224. #endif
  1225. #ifdef WIN_MOTIF
  1226.   /*
  1227.   XtVaSetValues (h, XmNsensitive, FALSE, NULL);
  1228.   */
  1229. #endif
  1230.   Nlm_RestorePort (tempPort);
  1231. }
  1232.  
  1233. static void Nlm_DisablePanel (Nlm_GraphiC p, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1234.  
  1235. {
  1236.   Nlm_SlatE  s;
  1237.  
  1238.   if (setFlag) {
  1239.     Nlm_SetEnabled (p, FALSE);
  1240.   }
  1241.   s = (Nlm_SlatE) Nlm_GetParent (p);
  1242.   Nlm_DoDisable ((Nlm_GraphiC) s, TRUE, savePort);
  1243. }
  1244.  
  1245. static void Nlm_ResetSlate (Nlm_GraphiC s, Nlm_Boolean savePort)
  1246.  
  1247. {
  1248.   Nlm_Handle       chdl;
  1249.   Nlm_BaR          hsb;
  1250.   Nlm_PaneL        n;
  1251.   Nlm_PoinT        npt;
  1252.   Nlm_PaneL        p;
  1253.   Nlm_PanelData    pdata;
  1254.   Nlm_RecT         r;
  1255.   Nlm_Handle       rhdl;
  1256.   Nlm_PnlActnProc  rst;
  1257.   Nlm_SlateData    sdata;
  1258.   Nlm_WindoW       tempPort;
  1259.   Nlm_BaR          vsb;
  1260.  
  1261.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1262.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1263.   rhdl = sdata.rowHandles;
  1264.   if (rhdl != NULL) {
  1265.     Nlm_HandFree (rhdl);
  1266.   }
  1267.   chdl = sdata.colHandles;
  1268.   if (chdl != NULL) {
  1269.     Nlm_HandFree (chdl);
  1270.   }
  1271.   sdata.rowHandles = NULL;
  1272.   sdata.colHandles = NULL;
  1273.   sdata.numRows = 0;
  1274.   sdata.numCols = 0;
  1275.   sdata.barRows = 0;
  1276.   sdata.vBefore = 0;
  1277.   sdata.vAfter = 0;
  1278.   sdata.vAction = NULL;
  1279.   Nlm_SetSlateData ((Nlm_SlatE) s, &sdata);
  1280.   vsb = sdata.vScrollBar;
  1281.   hsb = sdata.hScrollBar;
  1282.   if (vsb != NULL) {
  1283.     Nlm_DoReset ((Nlm_GraphiC) vsb, FALSE);
  1284.   }
  1285.   if (hsb != NULL) {
  1286.     Nlm_DoReset ((Nlm_GraphiC) hsb, FALSE);
  1287.   }
  1288.   Nlm_GetRect (s, &r);
  1289.   Nlm_InsetRect (&r, 4, 4);
  1290.   Nlm_LoadPt (&npt, r.left, r.top);
  1291.   Nlm_LoadBoxData ((Nlm_BoX) s, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  1292.   Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  1293.   if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  1294.       pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  1295.     p = (Nlm_PaneL) s;
  1296.     Nlm_GetRect ((Nlm_GraphiC) p, &r);
  1297.     Nlm_LoadPt (&npt, r.left, r.top);
  1298.     Nlm_LoadBoxData ((Nlm_BoX) p, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  1299.     rst = pdata.reset;
  1300.     if (rst != NULL) {
  1301.       rst (p);
  1302.     }
  1303.   } else {
  1304.     p = (Nlm_PaneL) Nlm_GetChild (s);
  1305.     while (p != NULL) {
  1306.       n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  1307.       Nlm_DoReset ((Nlm_GraphiC) p, FALSE);
  1308.       p = n;
  1309.     }
  1310.   }
  1311.   if (Nlm_GetVisible (s) && Nlm_GetAllParentsVisible (s) && Nlm_GetEnabled (s)) {
  1312.     Nlm_DoSelect (s, FALSE);
  1313.     Nlm_GetRect (s, &r);
  1314.     Nlm_InsetRect (&r, 1, 1);
  1315.     Nlm_EraseRect (&r);
  1316.     Nlm_ValidRect (&r);
  1317.   }
  1318.   Nlm_RestorePort (tempPort);
  1319. }
  1320.  
  1321. static void Nlm_ResetPanel (Nlm_GraphiC p, Nlm_Boolean savePort)
  1322.  
  1323. {
  1324.   Nlm_PoinT        npt;
  1325.   Nlm_PanelData    pdata;
  1326.   Nlm_RecT         r;
  1327.   Nlm_PnlActnProc  rst;
  1328.   Nlm_WindoW       tempPort;
  1329.  
  1330.   tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1331.   Nlm_GetRect (p, &r);
  1332.   Nlm_LoadPt (&npt, r.left, r.top);
  1333.   Nlm_LoadBoxData ((Nlm_BoX) p, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  1334.   Nlm_GetPanelData ((Nlm_PaneL) p, &pdata);
  1335.   rst = pdata.reset;
  1336.   if (rst != NULL) {
  1337.     rst ((Nlm_PaneL) p);
  1338.   }
  1339.   Nlm_RestorePort (tempPort);
  1340. }
  1341.  
  1342. static void Nlm_RemoveSlate (Nlm_GraphiC s, Nlm_Boolean savePort)
  1343.  
  1344. {
  1345.   Nlm_Handle       chdl;
  1346.   Nlm_SlateTool    h;
  1347.   Nlm_BaR          hsb;
  1348.   Nlm_PaneL        n;
  1349.   Nlm_PaneL        p;
  1350.   Nlm_PanelData    pdata;
  1351.   Nlm_Handle       rhdl;
  1352.   Nlm_PnlActnProc  rst;
  1353.   Nlm_SlateData    sdata;
  1354.   Nlm_WindoW       tempPort;
  1355.   Nlm_BaR          vsb;
  1356.  
  1357.   recentSlate = NULL;
  1358.   recentlyClickedSlate = NULL;
  1359.   recentlyClickedPanel = NULL;
  1360. #ifdef WIN_MOTIF
  1361.   if (Nlm_currentXDisplay != NULL) {
  1362.     XSync (Nlm_currentXDisplay, FALSE);
  1363.   }
  1364.   if (slateTimerUsed) {
  1365.     slateTimerUsed = FALSE;
  1366.     XtRemoveTimeOut (slateTimer);
  1367.   }
  1368.   if (Nlm_currentXDisplay != NULL) {
  1369.     XSync (Nlm_currentXDisplay, FALSE);
  1370.   }
  1371. #endif
  1372.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1373.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1374.   rhdl = sdata.rowHandles;
  1375.   if (rhdl != NULL) {
  1376.     Nlm_HandFree (rhdl);
  1377.   }
  1378.   chdl = sdata.colHandles;
  1379.   if (chdl != NULL) {
  1380.     Nlm_HandFree (chdl);
  1381.   }
  1382.   vsb = sdata.vScrollBar;
  1383.   hsb = sdata.hScrollBar;
  1384.   if (vsb != NULL) {
  1385.     Nlm_DoRemove ((Nlm_GraphiC) vsb, FALSE);
  1386.   }
  1387.   if (hsb != NULL) {
  1388.     Nlm_DoRemove ((Nlm_GraphiC) hsb, FALSE);
  1389.   }
  1390.   Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  1391.   if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  1392.       pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  1393.     p = (Nlm_PaneL) s;
  1394.     rst = pdata.reset;
  1395.     if (rst != NULL) {
  1396.       rst (p);
  1397.     }
  1398.   } else {
  1399.     p = (Nlm_PaneL) Nlm_GetChild (s);
  1400.     while (p != NULL) {
  1401.       n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  1402.       Nlm_DoReset ((Nlm_GraphiC) p, FALSE);
  1403.       Nlm_DoRemove ((Nlm_GraphiC) p, FALSE);
  1404.       p = n;
  1405.     }
  1406.   }
  1407.   h = sdata.handle;
  1408. #ifdef WIN_MSWIN
  1409.   RemoveProp (h, (LPSTR) "Nlm_VibrantProp");
  1410.   DestroyWindow (h);
  1411. #endif
  1412. #ifdef WIN_MOTIF
  1413.   XtDestroyWidget (h);
  1414. #endif
  1415.   Nlm_RemoveLink (s);
  1416.   recentSlate = NULL;
  1417.   recentlyClickedSlate = NULL;
  1418.   recentlyClickedPanel = NULL;
  1419.   Nlm_RestorePort (tempPort);
  1420. }
  1421.  
  1422. static void Nlm_RemovePanel (Nlm_GraphiC p, Nlm_Boolean savePort)
  1423.  
  1424. {
  1425.   Nlm_WindoW  tempPort;
  1426.  
  1427.   tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1428.   Nlm_RemoveLink (p);
  1429.   Nlm_RestorePort (tempPort);
  1430. }
  1431.  
  1432. static void Nlm_SelectSlate (Nlm_GraphiC s, Nlm_Boolean savePort)
  1433.  
  1434. {
  1435. #ifdef WIN_MOTIF
  1436.   Pixel          color;
  1437.   Nlm_SlateTool  h;
  1438.   Nlm_RecT       r;
  1439.   Nlm_WindoW     w;
  1440.  
  1441.   w = Nlm_ParentWindow (s);
  1442.   if (Nlm_WindowHasBeenShown (w) && (! Nlm_IsWindowDying (w))) {
  1443.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1444.     Nlm_GetRect (s, &r);
  1445.     Nlm_XOffset = r.left;
  1446.     Nlm_YOffset = r.top;
  1447.     Nlm_currentXWindow = XtWindow (h);
  1448.     XtVaGetValues (h, XmNbackground, &color, 0);
  1449.     Nlm_XbackColor = color;
  1450.     XtVaGetValues (h, XmNforeground, &color, 0);
  1451.     Nlm_XforeColor = color;
  1452.   }
  1453. #endif
  1454. }
  1455.  
  1456. static void Nlm_SelectPanel (Nlm_GraphiC p, Nlm_Boolean savePort)
  1457.  
  1458. {
  1459. #ifdef WIN_MOTIF
  1460.   Pixel          color;
  1461.   Nlm_SlateTool  h;
  1462.   Nlm_RecT       r;
  1463.   Nlm_SlatE      s;
  1464.   Nlm_WindoW     w;
  1465.  
  1466.   w = Nlm_ParentWindow (p);
  1467.   if (Nlm_WindowHasBeenShown (w) && (! Nlm_IsWindowDying (w))) {
  1468.     s = (Nlm_SlatE) Nlm_GetParent (p);
  1469.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1470.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  1471.     Nlm_XOffset = r.left;
  1472.     Nlm_YOffset = r.top;
  1473.     Nlm_currentXWindow = XtWindow (h);
  1474.     XtVaGetValues (h, XmNbackground, &color, 0);
  1475.     Nlm_XbackColor = color;
  1476.     XtVaGetValues (h, XmNforeground, &color, 0);
  1477.     Nlm_XforeColor = color;
  1478.   }
  1479. #endif
  1480. }
  1481.  
  1482. static void Nlm_SetSlateOffset (Nlm_GraphiC s, Nlm_Int2 horiz,
  1483.                                 Nlm_Int2 vert, Nlm_Boolean savePort)
  1484.  
  1485. {
  1486.   Nlm_BaR        hsb;
  1487.   Nlm_SlateData  sdata;
  1488.   Nlm_WindoW     tempPort;
  1489.   Nlm_BaR        vsb;
  1490.  
  1491.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1492.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1493.   /*
  1494.   if (vert > sdata.barRows) {
  1495.     vert = sdata.barRows;
  1496.   }
  1497.   */
  1498.   vsb = sdata.vScrollBar;
  1499.   hsb = sdata.hScrollBar;
  1500.   if (vsb != NULL) {
  1501.     Nlm_DoSetValue ((Nlm_GraphiC) vsb, vert + sdata.vBefore, FALSE);
  1502.   }
  1503.   if (hsb != NULL) {
  1504.     Nlm_DoSetValue ((Nlm_GraphiC) hsb, horiz, FALSE);
  1505.   }
  1506.   Nlm_RestorePort (tempPort);
  1507. }
  1508.  
  1509. static void Nlm_GetSlateOffset (Nlm_GraphiC s, Nlm_Int2Ptr horiz, Nlm_Int2Ptr vert)
  1510.  
  1511. {
  1512.   Nlm_BaR        hsb;
  1513.   Nlm_SlateData  sdata;
  1514.   Nlm_BaR        vsb;
  1515.  
  1516.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1517.   if (vert != NULL) {
  1518.     vsb = sdata.vScrollBar;
  1519.     if (vsb != NULL) {
  1520.       *vert = Nlm_DoGetValue ((Nlm_GraphiC) vsb) - sdata.vBefore;
  1521.     } else {
  1522.       *vert = 0;
  1523.     }
  1524.   }
  1525.   if (horiz != NULL) {
  1526.     hsb = sdata.hScrollBar;
  1527.     if (hsb != NULL) {
  1528.       *horiz = Nlm_DoGetValue ((Nlm_GraphiC) hsb);
  1529.     } else {
  1530.       *horiz = 0;
  1531.     }
  1532.   }
  1533. }
  1534.  
  1535. static void Nlm_GetPanelOffset (Nlm_GraphiC p,  Nlm_Int2Ptr horiz, Nlm_Int2Ptr vert)
  1536.  
  1537. {
  1538.   Nlm_Int2       hOff;
  1539.   Nlm_Int2       numRows;
  1540.   Nlm_OfsPtr     optr;
  1541.   Nlm_Handle     rhdl;
  1542.   Nlm_SlatE      s;
  1543.   Nlm_SlateData  sdata;
  1544.   Nlm_Int2       vOff;
  1545.  
  1546.   s = (Nlm_SlatE) Nlm_GetParent (p);
  1547.   Nlm_DoGetOffset ((Nlm_GraphiC) s, &hOff, &vOff);
  1548.   if (vert != NULL) {
  1549.     Nlm_GetSlateData (s, &sdata);
  1550.     numRows = sdata.numRows;
  1551.     rhdl = sdata.rowHandles;
  1552.     if (rhdl != NULL && vOff > 0 && vOff < numRows) {
  1553.       optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  1554.       *vert = optr [vOff].offset;
  1555.       Nlm_HandUnlock (rhdl);
  1556.     } else {
  1557.       *vert = 0;
  1558.     }
  1559.   }
  1560.   if (horiz != NULL) {
  1561.     *horiz = 0;
  1562.   }
  1563. }
  1564.  
  1565. static void Nlm_InvalSlate (Nlm_GraphiC s)
  1566.  
  1567. {
  1568.   Nlm_BaR   hsb;
  1569.   Nlm_RecT  r;
  1570.   Nlm_BaR   vsb;
  1571.  
  1572.   if (Nlm_GetVisible (s) && Nlm_GetAllParentsVisible (s)) {
  1573.     Nlm_GetRect (s, &r);
  1574.     vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1575.     hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1576.     if (vsb != NULL) {
  1577.       r.right += Nlm_vScrollBarWidth;
  1578.     }
  1579.     if (hsb != NULL) {
  1580.       r.bottom += Nlm_hScrollBarHeight;
  1581.     }
  1582.     Nlm_InsetRect (&r, -1, -1);
  1583.     Nlm_InvalRect (&r);
  1584.   }
  1585. }
  1586.  
  1587. static void Nlm_SetSlatePosition (Nlm_GraphiC s, Nlm_RectPtr r, Nlm_Boolean savePort)
  1588.  
  1589. {
  1590.   Nlm_Int2       deltaX;
  1591.   Nlm_Int2       deltaY;
  1592.   Nlm_SlateTool  h;
  1593.   Nlm_BaR        hsb;
  1594.   Nlm_RecT       oldRect;
  1595.   Nlm_PaneL      p;
  1596.   Nlm_RecT       pr;
  1597.   Nlm_RecT       sr;
  1598.   Nlm_WindoW     tempPort;
  1599.   Nlm_BaR        vsb;
  1600.  
  1601.   if (r != NULL) {
  1602.     Nlm_DoGetPosition (s, &oldRect);
  1603.     if (! Nlm_EqualRect (r, &oldRect)) {
  1604.       tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1605.       sr = *r;
  1606.       deltaX = sr.left - oldRect.left;
  1607.       deltaY = sr.top - oldRect.top;
  1608.       vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1609.       hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1610.       h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1611. #ifdef WIN_MAC
  1612.       Nlm_InvalSlate (s);
  1613.       if (vsb != NULL) {
  1614.         sr.right -= Nlm_vScrollBarWidth;
  1615.       }
  1616.       if (hsb != NULL) {
  1617.         sr.bottom -= Nlm_hScrollBarHeight;
  1618.       }
  1619.       Nlm_SetRect (s, &sr);
  1620.       Nlm_InvalSlate (s);
  1621. #endif
  1622. #ifdef WIN_MSWIN
  1623.       if (vsb != NULL) {
  1624.         sr.right -= Nlm_vScrollBarWidth;
  1625.       }
  1626.       if (hsb != NULL) {
  1627.         sr.bottom -= Nlm_hScrollBarHeight;
  1628.       }
  1629.       Nlm_SetRect (s, &sr);
  1630.       if (h != NULL) {
  1631.         MoveWindow (h, sr.left, sr.top, sr.right - sr.left, sr.bottom - sr.top, TRUE);
  1632.       }
  1633. #endif
  1634. #ifdef WIN_MOTIF
  1635. #ifdef DCLAP
  1636. /* dgg -- why aren't these corrections in motif also ? */
  1637.       if (vsb != NULL) {
  1638.         sr.right -= Nlm_vScrollBarWidth;
  1639.       }
  1640.       if (hsb != NULL) {
  1641.         sr.bottom -= Nlm_hScrollBarHeight;
  1642.       }
  1643.       XtVaSetValues (h,
  1644.                      XmNx, (Position) sr.left,
  1645.                      XmNy, (Position) sr.top,
  1646.                      XmNwidth, (Dimension) (sr.right - sr.left + 1),
  1647.                      XmNheight, (Dimension) (sr.bottom - sr.top + 1),
  1648.                      NULL);
  1649.       Nlm_SetRect (s, &sr);
  1650. #else
  1651.       XtVaSetValues (h,
  1652.                      XmNx, (Position) r->left,
  1653.                      XmNy, (Position) r->top,
  1654.                      XmNwidth, (Dimension) (r->right - r->left + 1),
  1655.                      XmNheight, (Dimension) (r->bottom - r->top + 1), 
  1656.                      NULL);
  1657.       Nlm_SetRect (s, &sr);
  1658. #endif
  1659.  
  1660. #endif
  1661.       p = (Nlm_PaneL) Nlm_GetChild (s);
  1662.       while (p != NULL) {
  1663.         Nlm_DoGetPosition ((Nlm_GraphiC) p, &pr);
  1664.         Nlm_OffsetRect (&pr, deltaX, deltaY);
  1665.         Nlm_DoSetPosition ((Nlm_GraphiC) p, &pr, FALSE);
  1666.         p = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  1667.       }
  1668. #ifdef WIN_MSWIN
  1669.       if (h != NULL) {
  1670.         UpdateWindow (h);
  1671.       }
  1672. #endif
  1673.       if (vsb != NULL) {
  1674.         Nlm_GetRect (s, &sr);
  1675.         sr.left = sr.right;
  1676.         sr.right += Nlm_vScrollBarWidth;
  1677.         Nlm_DoSetPosition ((Nlm_GraphiC) vsb, &sr, FALSE);
  1678.       }
  1679.       if (hsb != NULL) {
  1680.         Nlm_GetRect (s, &sr);
  1681.         sr.top = sr.bottom;
  1682.         sr.bottom += Nlm_hScrollBarHeight;
  1683.         Nlm_DoSetPosition ((Nlm_GraphiC) hsb, &sr, FALSE);
  1684.       }
  1685.       Nlm_RestorePort (tempPort);
  1686.     }
  1687.   }
  1688. }
  1689.  
  1690. static void Nlm_SetPanelPosition (Nlm_GraphiC p, Nlm_RectPtr r, Nlm_Boolean savePort)
  1691.  
  1692. {
  1693.   Nlm_RecT    oldRect;
  1694.   Nlm_WindoW  tempPort;
  1695.  
  1696.   if (r != NULL) {
  1697.     Nlm_DoGetPosition (p, &oldRect);
  1698.     if (! Nlm_EqualRect (r, &oldRect)) {
  1699.       tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1700.       Nlm_SetRect (p, r);
  1701.       Nlm_RestorePort (tempPort);
  1702.     }
  1703.   }
  1704. }
  1705.  
  1706. static void Nlm_GetSlatePosition (Nlm_GraphiC s, Nlm_RectPtr r)
  1707.  
  1708. {
  1709.   if (r != NULL) {
  1710.     Nlm_GetRect (s, r);
  1711.     if (Nlm_GetSlateVScrollBar ((Nlm_SlatE) s) != NULL) {
  1712.       r->right += Nlm_vScrollBarWidth;
  1713.     }
  1714.     if (Nlm_GetSlateHScrollBar ((Nlm_SlatE) s) != NULL) {
  1715.       r->bottom += Nlm_hScrollBarHeight;
  1716.     }
  1717.   }
  1718. }
  1719.  
  1720. static void Nlm_GetPanelPosition (Nlm_GraphiC p, Nlm_RectPtr r)
  1721.  
  1722. {
  1723.   if (r != NULL) {
  1724.     Nlm_GetRect (p, r);
  1725.   }
  1726. }
  1727.  
  1728. static void Nlm_AdjustSlate (Nlm_GraphiC a, Nlm_RectPtr r,
  1729.                              Nlm_Boolean align, Nlm_Boolean savePort)
  1730.  
  1731. {
  1732.   Nlm_SlatE  s;
  1733.  
  1734.   s = (Nlm_SlatE) Nlm_GetParent (a);
  1735.   Nlm_RecordRect ((Nlm_GraphiC) s, r);
  1736.   Nlm_NextPosition ((Nlm_GraphiC) s, r);
  1737. }
  1738.  
  1739. static void Nlm_SetSlateRange (Nlm_GraphiC s, Nlm_Int2 pgUp,
  1740.                                Nlm_Int2 pgDn, Nlm_Int2 max,
  1741.                                Nlm_Boolean savePort)
  1742.  
  1743. {
  1744.   Nlm_BaR        sb;
  1745.   Nlm_SlateData  sdata;
  1746.   Nlm_WindoW     tempPort;
  1747.  
  1748.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1749.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1750.   if (max > sdata.barRows) {
  1751.     sdata.barRows = max;
  1752.     Nlm_SetSlateData ((Nlm_SlatE) s, &sdata);
  1753.   }
  1754.   sb = sdata.vScrollBar;
  1755.   if (sb != NULL) {
  1756.     Nlm_DoSetRange ((Nlm_GraphiC) sb, pgUp, pgDn, max, FALSE);
  1757.   }
  1758.   Nlm_RestorePort (tempPort);
  1759. }
  1760.  
  1761. static void Nlm_NextScreenLine (Nlm_DisplaY d)
  1762.  
  1763. {
  1764.   Nlm_RecT   p;
  1765.   Nlm_PoinT  pt;
  1766.   Nlm_RecT   r;
  1767.  
  1768.   Nlm_GetCursorPos (d, &pt);
  1769.   Nlm_GetRect ((Nlm_GraphiC) d, &r);
  1770.   Nlm_InsetRect (&r, 4, 4);
  1771.   p = r;
  1772. #ifdef WIN_MSWIN
  1773.   r.bottom -= disphght;
  1774. #endif
  1775.   while (pt.y + disphght >= r.bottom) {
  1776.     Nlm_ScrollRect (&p, 0, -disphght);
  1777.     pt.y -= disphght;
  1778.   }
  1779.   if (pt.y + disphght >= r.bottom) {
  1780.     Nlm_ScrollRect (&p, 0, -disphght);
  1781.   } else {
  1782.     pt.y += disphght;
  1783.   }
  1784.   pt.x = r.left;
  1785.   Nlm_SetCursorPos (d, pt);
  1786. }
  1787.  
  1788. static void Nlm_PaintOneCharacter (Nlm_DisplaY d, Nlm_Char ch)
  1789.  
  1790. {
  1791.   Nlm_PoinT  nx;
  1792.   Nlm_PoinT  pt;
  1793.   Nlm_RecT   r;
  1794.  
  1795.   Nlm_GetCursorPos (d, &pt);
  1796.   Nlm_GetRect ((Nlm_GraphiC) d, &r);
  1797.   Nlm_InsetRect (&r, 4, 4);
  1798.   nx = pt;
  1799.   nx.x += Nlm_CharWidth (ch);
  1800. #ifdef WIN_MSWIN
  1801.   nx.y -= disphght;
  1802. #endif
  1803.   if (Nlm_PtInRect (pt, &r) && Nlm_PtInRect (nx, &r)) {
  1804.   } else {
  1805.     screenPos = 0;
  1806.     Nlm_NextScreenLine (d);
  1807.   }
  1808.   Nlm_GetCursorPos (d, &pt);
  1809.   nx = pt;
  1810.   nx.x += Nlm_CharWidth (ch);
  1811.   if (Nlm_PtInRect (pt, &r) && Nlm_PtInRect (nx, &r)) {
  1812.     Nlm_MoveTo (pt.x, pt.y);
  1813.     Nlm_PaintChar (ch);
  1814.     Nlm_SetCursorPos (d, nx);
  1815.     if (screenPos < screenBufSize) {
  1816.       screenBfr [screenPos] = ch;
  1817.     }
  1818.     screenPos++;
  1819.   }
  1820. }
  1821.  
  1822. static void Nlm_EraseLastChar (Nlm_DisplaY d)
  1823.  
  1824. {
  1825.   Nlm_Char   ch;
  1826.   Nlm_PoinT  pt;
  1827.  
  1828.   if (screenPos > 0) {
  1829.     screenPos--;
  1830.     if (screenPos < screenBufSize) {
  1831.       Nlm_GetCursorPos (d, &pt);
  1832.       ch = screenBfr [screenPos];
  1833.       pt.x -= Nlm_CharWidth (ch);
  1834.       Nlm_MoveTo (pt.x, pt.y);
  1835.       Nlm_SetCursorPos (d, pt);
  1836.       Nlm_InvertMode ();
  1837.       Nlm_PaintOneCharacter (d, ch);
  1838.       Nlm_MoveTo (pt.x, pt.y);
  1839.       Nlm_SetCursorPos (d, pt);
  1840.       screenPos--;
  1841.       Nlm_CopyMode ();
  1842.     }
  1843.   }
  1844. }
  1845.  
  1846. static void Nlm_PaintOrFormatChar (Nlm_GraphiC d, Nlm_Char ch, Nlm_Boolean savePort)
  1847.  
  1848. {
  1849.   Nlm_PoinT   pt;
  1850.   Nlm_RecT    r;
  1851.   Nlm_WindoW  tempPort;
  1852. #ifdef WIN_MAC
  1853.   PenState    state;
  1854. #endif
  1855.  
  1856.   if (Nlm_GetVisible (d) && Nlm_AllParentsButWindowVisible (d)) {
  1857.     tempPort = Nlm_SavePortIfNeeded (d, savePort);
  1858.     Nlm_DoSelect (d, FALSE);
  1859. #ifdef WIN_MAC
  1860.     GetPenState (&state);
  1861.     PenNormal ();
  1862. #endif
  1863.     Nlm_SelectFont (dispfont);
  1864.     switch (ch) {
  1865.       case '\n':
  1866.         screenPos = 0;
  1867.         Nlm_NextScreenLine ((Nlm_DisplaY) d);
  1868.         break;
  1869.       case '\r':
  1870. #ifndef WIN_MSWIN
  1871.         screenPos = 0;
  1872.         Nlm_NextScreenLine ((Nlm_DisplaY) d);
  1873. #endif
  1874.         break;
  1875.       case '\t':
  1876.         do {
  1877.           Nlm_PaintOneCharacter ((Nlm_DisplaY) d, ' ');
  1878.         } while ((screenPos % 8) != 0);
  1879.         break;
  1880.       case '\b':
  1881.         if (screenPos > 0) {
  1882.           Nlm_EraseLastChar ((Nlm_DisplaY) d);
  1883.         }
  1884.         break;
  1885.       case '\f':
  1886.         screenPos = 0;
  1887.         Nlm_GetRect (d, &r);
  1888.         Nlm_LoadPt (&pt, r.left, r.top + disphght);
  1889.         Nlm_SetCursorPos ((Nlm_DisplaY) d, pt);
  1890.         Nlm_InsetRect (&r, 2, 2);
  1891.         Nlm_EraseRect (&r);
  1892.         break;
  1893.       case '\7':
  1894.         Nlm_Beep ();
  1895.         break;
  1896.       default:
  1897.         if (ch >= ' ') {
  1898.           Nlm_PaintOneCharacter ((Nlm_DisplaY) d, ch);
  1899.         }
  1900.         break;
  1901.     }
  1902. #ifdef WIN_MAC
  1903.     SetPenState (&state);
  1904. #endif
  1905.     Nlm_SelectFont (Nlm_systemFont);
  1906.     Nlm_RestorePort (tempPort);
  1907.   }
  1908. }
  1909.  
  1910. static void Nlm_SelectDisplay (Nlm_GraphiC d, Nlm_Boolean savePort)
  1911.  
  1912. {
  1913.   Nlm_WindoW  w;
  1914.  
  1915.   if (Nlm_WindowHasBeenShown (Nlm_ParentWindow (d))) {
  1916.     w = Nlm_GetParentWindow (d);
  1917.     Nlm_SetWindowCharDisplay (w, (Nlm_DisplaY) d);
  1918.   }
  1919. }
  1920.  
  1921. #ifdef WIN_MOTIF
  1922. #define MOUSE_DOWN 1
  1923. #define MOUSE_MOVE 2
  1924. #define MOUSE_UP   3
  1925.  
  1926. static void Nlm_SlateTimer (XtPointer client_data, XtIntervalId *id)
  1927.  
  1928. {
  1929.   Nlm_PaneL        p;
  1930.   Nlm_PnlClckProc  prs;
  1931.   Nlm_PoinT        pt;
  1932.   Nlm_SlatE        s;
  1933.  
  1934.   if (slateTimerUsed) {
  1935.     s = (Nlm_SlatE) client_data;
  1936.     pt = currentMousePos;
  1937.     if ((Nlm_SlatE) s == recentlyClickedSlate &&
  1938.         recentlyClickedSlate != NULL && recentlyClickedPanel != NULL) {
  1939.       p = recentlyClickedPanel;
  1940.       Nlm_DoSelect ((Nlm_GraphiC) p, FALSE);
  1941.       prs = Nlm_GetPanelHold (p);
  1942.       if (prs != NULL) {
  1943.         Nlm_ResetDrawingTools ();
  1944.         prs (p, pt);
  1945.       }
  1946.     }
  1947.     slateTimer = XtAppAddTimeOut (Nlm_appContext, 50, Nlm_SlateTimer, (XtPointer) s);
  1948.     slateTimerUsed = TRUE;
  1949.   }
  1950. }
  1951.  
  1952. static void Nlm_SlateClick (Nlm_SlatE s, Nlm_PoinT pt, Nlm_Int2 mouseAction)
  1953.  
  1954. {
  1955.   Nlm_PnlClckProc  clk;
  1956.   Nlm_PnlClckProc  drg;
  1957.   Nlm_SlateTool    h;
  1958.   Nlm_Int2         hOffset;
  1959.   Nlm_PaneL        n;
  1960.   Nlm_Boolean      notInside;
  1961.   Nlm_PaneL        p;
  1962.   Nlm_PanelData    pdata;
  1963.   Nlm_PnlClckProc  prs;
  1964.   Nlm_RecT         r;
  1965.   Nlm_PnlClckProc  rls;
  1966.   Nlm_Int2         vOffset;
  1967.   Nlm_Int2         x;
  1968.   Nlm_Int2         y;
  1969.  
  1970.   h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1971.   currentMousePos = pt;
  1972.   switch (mouseAction) {
  1973.     case MOUSE_DOWN:
  1974.       slateTimer = XtAppAddTimeOut (Nlm_appContext, 50, Nlm_SlateTimer, (XtPointer) s);
  1975.       slateTimerUsed = TRUE;
  1976.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  1977.       recentlyClickedSlate = (Nlm_SlatE) s;
  1978.       recentlyClickedPanel = NULL;
  1979.       Nlm_SelectFont (Nlm_systemFont);
  1980.       Nlm_ResetDrawingTools ();
  1981.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  1982.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  1983.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  1984.         p = (Nlm_PaneL) s;
  1985.         recentlyClickedPanel = p;
  1986.         clk = Nlm_GetPanelClick (p);
  1987.         if (clk != NULL && Nlm_GetEnabled ((Nlm_GraphiC) p)
  1988.             && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  1989.           clk (p, pt);
  1990.           Nlm_Update ();
  1991.         }
  1992.       } else {
  1993.         p = Nlm_CreateReverseLinks ((Nlm_SlatE) s);
  1994.         notInside = TRUE;
  1995.         while (p != NULL && notInside) {
  1996.           n = Nlm_GetPanelPrev (p);
  1997.           Nlm_GetPanelData (p, &pdata);
  1998.           if (pdata.click != NULL || pdata.drag != NULL ||
  1999.               pdata.hold != NULL || pdata.release != NULL) {
  2000.             Nlm_GetRect ((Nlm_GraphiC) p, &r);
  2001.             Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  2002.             Nlm_OffsetRect (&r, -hOffset, -vOffset);
  2003.             if (Nlm_PtInRect (pt, &r) && Nlm_GetEnabled ((Nlm_GraphiC) p) &&
  2004.                 Nlm_GetVisible ((Nlm_GraphiC) p)) {
  2005.               recentlyClickedPanel = p;
  2006.               notInside = FALSE;
  2007.               clk = Nlm_GetPanelClick (p);
  2008.               if (clk != NULL) {
  2009.                 clk (p, pt);
  2010.                 Nlm_Update ();
  2011.               }
  2012.             }
  2013.           }
  2014.           p = n;
  2015.         }
  2016.       }
  2017.       break;
  2018.     case MOUSE_MOVE:
  2019.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2020.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  2021.         p = recentlyClickedPanel;
  2022.         drg = Nlm_GetPanelDrag (p);
  2023.         if (drg != NULL) {
  2024.           Nlm_ResetDrawingTools ();
  2025.           drg (p, pt);
  2026.         }
  2027.       }
  2028.       break;
  2029.     case MOUSE_UP:
  2030.       if (slateTimerUsed) {
  2031.         XtRemoveTimeOut (slateTimer);
  2032.       }
  2033.       slateTimerUsed = FALSE;
  2034.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2035.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  2036.         p = recentlyClickedPanel;
  2037.         rls = Nlm_GetPanelRelease (p);
  2038.         if (rls != NULL) {
  2039.           Nlm_ResetDrawingTools ();
  2040.           rls (p, pt);
  2041.         }
  2042.       }
  2043.       Nlm_SelectFont (Nlm_systemFont);
  2044.       Nlm_ResetDrawingTools ();
  2045. /*
  2046.       recentlyClickedSlate = NULL;
  2047. */
  2048.       recentlyClickedPanel = NULL;
  2049.       break;
  2050.     default:
  2051.       break;
  2052.   }
  2053. }
  2054.  
  2055. static void Nlm_SlateClickCallback (Widget w, XEvent *ev,
  2056.                                     String *args, Cardinal *num_args)
  2057.  
  2058. {
  2059.   XButtonEvent  *event;
  2060.   Pixel         color;
  2061.   Nlm_Uint4     delta;
  2062.   Nlm_WindoW    newWindow;
  2063.   Nlm_WindoW    oldWindow;
  2064.   Nlm_PoinT     pt;
  2065.   XtPointer     ptr;
  2066.   Nlm_RecT      r;
  2067.   Nlm_SlatE     s;
  2068.   Nlm_Uint4     state;
  2069.   Window        tempWind;
  2070.   Nlm_Uint4     ticks;
  2071.  
  2072.   event = (XButtonEvent *) ev;
  2073.   XtVaGetValues (w, XmNuserData, &ptr, NULL);
  2074.   s = (Nlm_SlatE) ptr;
  2075.   if (Nlm_GetEnabled ((Nlm_GraphiC) s) && Nlm_GetAllParentsEnabled ((Nlm_GraphiC) s)) {
  2076.     newWindow = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  2077.     if (! Nlm_IsWindowDying (newWindow)) {
  2078.       oldWindow = Nlm_CurrentWindow ();
  2079.       if (oldWindow != newWindow) {
  2080.         Nlm_UseWindow (newWindow);
  2081.       }
  2082.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2083.       Nlm_XOffset = r.left;
  2084.       Nlm_YOffset = r.top;
  2085.       tempWind = Nlm_currentXWindow;
  2086.       Nlm_currentXWindow = XtWindow (w);
  2087.       XtVaGetValues (w, XmNbackground, &color, 0);
  2088.       Nlm_XbackColor = color;
  2089.       XtVaGetValues (w, XmNforeground, &color, 0);
  2090.       Nlm_XforeColor = color;
  2091.       pt.x = (Nlm_Int2) event->x + Nlm_XOffset;
  2092.       pt.y = (Nlm_Int2) event->y + Nlm_YOffset;
  2093.       Nlm_cmmdKey = FALSE;
  2094.       Nlm_ctrlKey = FALSE;
  2095.       Nlm_optKey = FALSE;
  2096.       Nlm_shftKey = FALSE;
  2097.       Nlm_dblClick = FALSE;
  2098.       state = event->state;
  2099.       if ((state &ControlMask) != 0) {
  2100.         Nlm_ctrlKey = TRUE;
  2101.       }
  2102.       if ((state &ShiftMask) != 0) {
  2103.         Nlm_shftKey = TRUE;
  2104.       }
  2105.       if (strcmp (args [0], "down") == 0) {
  2106.         ticks = (Nlm_Uint4) event->time;
  2107.         if (s == recentlyClickedSlate) {
  2108.           delta = ticks - (Nlm_Uint4) lastClickTime;
  2109.           if (delta <= (Nlm_Uint4) XtGetMultiClickTime (Nlm_currentXDisplay)) {
  2110.             Nlm_dblClick = TRUE;
  2111.           }
  2112.         }
  2113.         lastClickTime = (Nlm_Int4) ticks;
  2114.         Nlm_SlateClick (s, pt, MOUSE_DOWN);
  2115.       } else if (strcmp (args [0], "up") == 0) {
  2116.         Nlm_SlateClick (s, pt, MOUSE_UP);
  2117.       } else if (strcmp (args [0], "motion") == 0) {
  2118.         Nlm_SlateClick (s, pt, MOUSE_MOVE);
  2119.       }
  2120.       if (Nlm_currentXDisplay != NULL) {
  2121.         XSync (Nlm_currentXDisplay, FALSE);
  2122.       }
  2123.       Nlm_currentXWindow = tempWind;
  2124.       if (oldWindow != newWindow) {
  2125.         Nlm_UseWindow (oldWindow);
  2126.       }
  2127.     }
  2128.   }
  2129. }
  2130.  
  2131. static void Nlm_SlateKeyCallback (Widget w, XEvent *ev,
  2132.                                   String *args, Cardinal *num_args)
  2133.  
  2134. {
  2135.   XKeyEvent        *event;
  2136.   Nlm_Char         buffer [20];
  2137.   Nlm_Char         ch;
  2138.   int              charcount;
  2139.   XComposeStatus   compose;
  2140.   KeySym           keysym;
  2141.   Pixel            color;
  2142.   Nlm_Uint4        delta;
  2143.   Nlm_SltCharProc  keyProc;
  2144.   Nlm_WindoW       newWindow;
  2145.   Nlm_WindoW       oldWindow;
  2146.   XtPointer        ptr;
  2147.   Nlm_RecT         r;
  2148.   Nlm_SlatE        s;
  2149.   Nlm_Uint4        state;
  2150.   Window           tempWind;
  2151.  
  2152.   event = (XKeyEvent *) ev;
  2153.   XtVaGetValues (w, XmNuserData, &ptr, NULL);
  2154.   s = (Nlm_SlatE) ptr;
  2155.   if (Nlm_GetEnabled ((Nlm_GraphiC) s) && Nlm_GetAllParentsEnabled ((Nlm_GraphiC) s)) {
  2156.     newWindow = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  2157.     if (! Nlm_IsWindowDying (newWindow)) {
  2158.       oldWindow = Nlm_CurrentWindow ();
  2159.       if (oldWindow != newWindow) {
  2160.         Nlm_UseWindow (newWindow);
  2161.       }
  2162.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2163.       Nlm_XOffset = r.left;
  2164.       Nlm_YOffset = r.top;
  2165.       tempWind = Nlm_currentXWindow;
  2166.       Nlm_currentXWindow = XtWindow (w);
  2167.       XtVaGetValues (w, XmNbackground, &color, 0);
  2168.       Nlm_XbackColor = color;
  2169.       XtVaGetValues (w, XmNforeground, &color, 0);
  2170.       Nlm_XforeColor = color;
  2171.       Nlm_cmmdKey = FALSE;
  2172.       Nlm_ctrlKey = FALSE;
  2173.       Nlm_optKey = FALSE;
  2174.       Nlm_shftKey = FALSE;
  2175.       Nlm_dblClick = FALSE;
  2176.       state = event->state;
  2177.       if ((state &ControlMask) != 0) {
  2178.         Nlm_ctrlKey = TRUE;
  2179.       }
  2180.       if ((state &ShiftMask) != 0) {
  2181.         Nlm_shftKey = TRUE;
  2182.       }
  2183.       if (ev->type == KeyPress && strcmp (args [0], "key") == 0) {
  2184.         buffer [0] = '\0';
  2185.         charcount = XLookupString (&(ev->xkey), buffer, 20, &keysym, &compose);
  2186.         if (charcount >= 0 && charcount < 20) {
  2187.           buffer [charcount] = '\0';
  2188.         }
  2189.         keyProc = Nlm_GetSlateCharProc (s);
  2190.         if (keyProc != NULL) {
  2191.           ch = buffer [0];
  2192.           keyProc (s, ch);
  2193.         }
  2194.       }
  2195.       if (Nlm_currentXDisplay != NULL) {
  2196.         XSync (Nlm_currentXDisplay, FALSE);
  2197.       }
  2198.       Nlm_currentXWindow = tempWind;
  2199.       if (oldWindow != newWindow) {
  2200.         Nlm_UseWindow (oldWindow);
  2201.       }
  2202.     }
  2203.   }
  2204. }
  2205.  
  2206. static void Nlm_DrawSlate (Nlm_SlatE s)
  2207.  
  2208. {
  2209.   Nlm_PnlActnProc  drw;
  2210.   Nlm_SlateTool    h;
  2211.   Nlm_PaneL        n;
  2212.   Nlm_PaneL        p;
  2213.   Nlm_PanelData    pdata;
  2214.   Nlm_RecT         r;
  2215.  
  2216.   if (Nlm_GetVisible ((Nlm_GraphiC) s) && Nlm_GetAllParentsVisible ((Nlm_GraphiC) s)) {
  2217.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  2218.     if (h != NULL) {
  2219.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2220.       Nlm_SelectFont (Nlm_systemFont);
  2221.       Nlm_ResetDrawingTools ();
  2222.             Nlm_DrawSlateBorder( s);
  2223.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  2224.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  2225.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  2226.         p = (Nlm_PaneL) s;
  2227. /*
  2228.         recentlyClickedPanel = p;
  2229. */
  2230.         drw = Nlm_GetPanelDraw (p);
  2231.         if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  2232.           drw (p);
  2233.           Nlm_ResetDrawingTools ();
  2234.         }
  2235.       } else {
  2236.         p = (Nlm_PaneL) Nlm_GetChild ((Nlm_GraphiC) s);
  2237.         while (p != NULL) {
  2238.           n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  2239.           drw = Nlm_GetPanelDraw (p);
  2240.           if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  2241.             drw (p);
  2242.             Nlm_ResetDrawingTools ();
  2243.           }
  2244.           p = n;
  2245.         }
  2246.       }
  2247.     }
  2248.   }
  2249. }
  2250.  
  2251. static void Nlm_ClipXRgn (Nlm_RegioN rgn)
  2252.  
  2253. {
  2254.   Nlm_RgnTool  ntool1;
  2255.   Nlm_RgnTool  ntool2;
  2256.  
  2257.   if (rgn != NULL && Nlm_currentXDisplay != NULL && Nlm_currentXGC != NULL) {
  2258.     ntool1 = XCreateRegion ();
  2259.     ntool2 = XCreateRegion ();
  2260.     XUnionRegion ((Nlm_RgnTool) rgn, ntool1, ntool2);
  2261.     XOffsetRegion (ntool2, -Nlm_XOffset, -Nlm_YOffset);
  2262.     XSetRegion (Nlm_currentXDisplay, Nlm_currentXGC, ntool2);
  2263.     if (Nlm_clpRgn != NULL) {
  2264.       XDestroyRegion ((Nlm_RgnTool) Nlm_clpRgn);
  2265.       Nlm_clpRgn = NULL;
  2266.     }
  2267.     Nlm_clpRgn = (Nlm_RegioN) XCreateRegion ();
  2268.     XUnionRegion ((Nlm_RgnTool) rgn, ntool1, (Nlm_RgnTool) Nlm_clpRgn);
  2269.     XOffsetRegion ((Nlm_RgnTool) Nlm_clpRgn, -Nlm_XOffset, -Nlm_YOffset);
  2270.     XDestroyRegion (ntool1);
  2271.     XDestroyRegion (ntool2);
  2272.   }
  2273. }
  2274.  
  2275. static void Nlm_SlateDrawCallback (Widget w, XtPointer client_data, XtPointer call_data)
  2276.  
  2277. {
  2278.   XmDrawingAreaCallbackStruct  *cbs;
  2279.   Pixel                        color;
  2280.   XEvent                       event;
  2281.   Nlm_WindoW                   newWindow;
  2282.   Nlm_WindoW                   oldWindow;
  2283.   Nlm_RecT                     r;
  2284.   Nlm_RegioN                   rgn1;
  2285.   Nlm_RegioN                   rgn2;
  2286.   Nlm_SlatE                    s;
  2287.   Nlm_RegioN                   tempRgn;
  2288.   Window                       tempWind;
  2289.  
  2290.   cbs = (XmDrawingAreaCallbackStruct *) call_data;
  2291.   s = (Nlm_SlatE) client_data;
  2292.   newWindow = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  2293.   if (! Nlm_IsWindowDying (newWindow)) {
  2294.     oldWindow = Nlm_CurrentWindow ();
  2295.     if (oldWindow != newWindow) {
  2296.       Nlm_UseWindow (newWindow);
  2297.     }
  2298.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2299.     Nlm_XOffset = r.left;
  2300.     Nlm_YOffset = r.top;
  2301.     tempWind = Nlm_currentXWindow;
  2302.     Nlm_currentXWindow = XtWindow (w);
  2303.     XtVaGetValues (w, XmNbackground, &color, 0);
  2304.     Nlm_XbackColor = color;
  2305.     XtVaGetValues (w, XmNforeground, &color, 0);
  2306.     Nlm_XforeColor = color;
  2307.     rgn1 = Nlm_CreateRgn ();
  2308.     event = (*(cbs->event));
  2309.     do {
  2310.       r.left = event.xexpose.x;
  2311.       r.top = event.xexpose.y;
  2312.       r.right = r.left + event.xexpose.width;
  2313.       r.bottom = r.top + event.xexpose.height;
  2314.       rgn2 = Nlm_CreateRgn ();
  2315.       Nlm_LoadRectRgn (rgn2, r.left, r.top, r.right, r.bottom);
  2316.       Nlm_UnionRgn (rgn1, rgn2, rgn1);
  2317.       Nlm_DestroyRgn (rgn2);
  2318.     } while (XCheckTypedWindowEvent (Nlm_currentXDisplay,
  2319.              Nlm_currentXWindow, Expose, &event));
  2320.     Nlm_OffsetRgn (rgn1, Nlm_XOffset, Nlm_YOffset);
  2321.     Nlm_ClipXRgn (rgn1);
  2322.     Nlm_DestroyRgn (rgn1);
  2323.     if (Nlm_updateRgn != NULL) {
  2324.       Nlm_DestroyRgn (Nlm_updateRgn);
  2325.     }
  2326.     Nlm_updateRgn = Nlm_CreateRgn ();
  2327.     tempRgn = Nlm_CreateRgn ();
  2328.     Nlm_UnionRgn (Nlm_clpRgn, tempRgn, Nlm_updateRgn);
  2329.     Nlm_DestroyRgn (tempRgn);
  2330.     XOffsetRegion ((Nlm_RgnTool) Nlm_updateRgn, Nlm_XOffset, Nlm_YOffset);
  2331.     Nlm_DrawSlate (s);
  2332.     if (Nlm_currentXDisplay != NULL && Nlm_currentXGC != NULL) {
  2333.       XSetClipMask (Nlm_currentXDisplay, Nlm_currentXGC, None);
  2334.       if (Nlm_clpRgn != NULL) {
  2335.         XDestroyRegion ((Nlm_RgnTool) Nlm_clpRgn);
  2336.         Nlm_clpRgn = NULL;
  2337.       }
  2338.     }
  2339.     if (Nlm_currentXDisplay != NULL) {
  2340.       XSync (Nlm_currentXDisplay, FALSE);
  2341.     }
  2342.     Nlm_currentXWindow = tempWind;
  2343.     if (oldWindow != newWindow) {
  2344.       Nlm_UseWindow (oldWindow);
  2345.     }
  2346.   }
  2347. }
  2348. #endif
  2349.  
  2350. static void Nlm_NewSlate (Nlm_SlatE s, Nlm_Boolean border,
  2351.                           Nlm_Boolean vScroll, Nlm_Boolean hScroll,
  2352.                           Nlm_SltScrlProc vscrl, Nlm_SltScrlProc hscrl,
  2353.                           Nlm_Int2 extra)
  2354.  
  2355. {
  2356.   Nlm_SlateTool   h;
  2357.   Nlm_BaR         hsb;
  2358.   Nlm_PoinT       npt;
  2359.   Nlm_RecT        r;
  2360.   Nlm_BaR         vsb;
  2361.   Nlm_WindowTool  wptr;
  2362. #ifdef WIN_MOTIF
  2363.   Cardinal        n;
  2364.   Arg             wargs [10];
  2365.   String          trans =
  2366.     "<Btn1Down>:     slate(down)   ManagerGadgetArm()  \n\
  2367.      <Btn1Up>:       slate(up)     ManagerGadgetActivate() \n\
  2368.      <Btn1Motion>:   slate(motion) ManagerGadgetButtonMotion() \n\
  2369.      <Key>:          piano(key)    ManagerGadgetActivate()";
  2370. #endif
  2371.  
  2372.   Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2373. #ifdef DCLAP
  2374.     Nlm_InsetRect( &r, 1, 1); /* for border outset */
  2375. #endif
  2376.   h = NULL;
  2377.   vsb = NULL;
  2378.   hsb = NULL;
  2379.   wptr = Nlm_ParentWindowPtr ((Nlm_GraphiC) s);
  2380. #ifdef WIN_MSWIN
  2381.   h = CreateWindow (slateclass, "", WS_CHILD,
  2382.                     r.left, r.top, r.right - r.left,
  2383.                     r.bottom - r.top, wptr, 0,
  2384.                     Nlm_currentHInst, NULL);
  2385.   if (h != NULL) {
  2386.     SetProp (h, (LPSTR) "Nlm_VibrantProp", (Nlm_HandleTool) s);
  2387.   }
  2388. #endif
  2389. #ifdef WIN_MOTIF
  2390.   n = 0;
  2391.   XtSetArg (wargs [n], XmNx, (Position) r.left); n++;
  2392.   XtSetArg (wargs [n], XmNy, (Position) r.top); n++;
  2393.   XtSetArg (wargs [n], XmNwidth, (Dimension) (r.right - r.left + 1)); n++;
  2394.   XtSetArg (wargs [n], XmNheight, (Dimension) (r.bottom - r.top + 1)); n++;
  2395.   XtSetArg (wargs [n], XmNmarginHeight, 0); n++;
  2396.   XtSetArg (wargs [n], XmNmarginWidth, 0); n++;
  2397.   XtSetArg (wargs [n], XmNborderWidth, (Dimension) 0); n++;
  2398.   XtSetArg (wargs [n], XmNtranslations, XtParseTranslationTable (trans)); n++;
  2399.   h = XtCreateManagedWidget ((String) "", xmDrawingAreaWidgetClass,
  2400.                              wptr, wargs, n);
  2401.   XtVaSetValues (h, XmNuserData, (XtPointer) s, NULL);
  2402.   XtAddCallback (h, XmNexposeCallback, Nlm_SlateDrawCallback, (XtPointer) s);
  2403.   if (NLM_QUIET) {
  2404.     if (Nlm_WindowHasBeenShown (Nlm_ParentWindow (s))) {
  2405.       XtRealizeWidget (h);
  2406.     }
  2407.   } else {
  2408.     XtRealizeWidget (h);
  2409.   }
  2410. #endif
  2411.   if (vScroll) {
  2412.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2413.     r.left = r.right;
  2414.     r.right += Nlm_vScrollBarWidth;
  2415.     if (vscrl != NULL) {
  2416.       vsb = Nlm_VertScrollBar ((Nlm_GraphiC) s, &r, (Nlm_ScrlProc) vscrl);
  2417.     } else {
  2418.       vsb = Nlm_VertScrollBar ((Nlm_GraphiC) s, &r,
  2419.                                (Nlm_ScrlProc) Nlm_SlateVertScrollAction);
  2420.     }
  2421.   }
  2422.   if (hScroll) {
  2423.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2424.     r.top = r.bottom;
  2425.     r.bottom += Nlm_hScrollBarHeight;
  2426.     if (hscrl != NULL) {
  2427.       hsb = Nlm_HorizScrollBar ((Nlm_GraphiC) s, &r, (Nlm_ScrlProc) hscrl);
  2428.     } else {
  2429.       hsb = Nlm_HorizScrollBar ((Nlm_GraphiC) s, &r,
  2430.                                 (Nlm_ScrlProc) Nlm_SlateHorizScrollAction);
  2431.     }
  2432.   }
  2433.   Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2434.   Nlm_InsetRect (&r, 4, 4);
  2435.   Nlm_LoadPt (&npt, r.left, r.top);
  2436.   Nlm_LoadBoxData ((Nlm_BoX) s, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  2437.   Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2438.   Nlm_LoadSlateData (s, h, vsb, hsb, NULL, NULL, 0, 0,
  2439.                      border, 0, 0, 0, NULL, NULL, FALSE);
  2440.   Nlm_LoadPanelData ((Nlm_PaneL) s, NULL, NULL, NULL, NULL, NULL, extra, NULL, NULL);
  2441. }
  2442.  
  2443. static void Nlm_NewPanel (Nlm_PaneL p, Nlm_PnlActnProc draw,
  2444.                           Nlm_Int2 extra, Nlm_PnlActnProc reset)
  2445.  
  2446. /*
  2447. *  MemNew already sets the extra data to NULL.  If the window is visible,
  2448. *  the draw request may occur before the extra data is initialized.
  2449. */
  2450.  
  2451. {
  2452.   Nlm_PoinT  npt;
  2453.   Nlm_RecT   r;
  2454.  
  2455.   Nlm_GetRect ((Nlm_GraphiC) p, &r);
  2456.   Nlm_LoadPt (&npt, r.left, r.top);
  2457.   Nlm_LoadBoxData ((Nlm_BoX) p, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  2458.   Nlm_LoadPanelData (p, NULL, NULL, NULL, NULL, draw, extra, reset, NULL);
  2459. }
  2460.  
  2461. static void Nlm_NewDisplay (Nlm_DisplaY d)
  2462.  
  2463. {
  2464.   Nlm_PoinT   pos;
  2465.   Nlm_RecT    r;
  2466.   Nlm_Int2    vis;
  2467.   Nlm_WindoW  w;
  2468.  
  2469.   Nlm_GetRect ((Nlm_GraphiC) d, &r);
  2470.   Nlm_InsetRect (&r, 4, 4);
  2471.   Nlm_LoadPt (&pos, r.left, r.top + disphght);
  2472.   if (disphght > 0) {
  2473.     vis = (r.bottom - r.top + 1) / disphght;
  2474.   } else {
  2475.     vis = 0;
  2476.   }
  2477.   Nlm_LoadDisplayData (d, FALSE, FALSE, NULL, 0, vis, pos);
  2478.   w = Nlm_GetParentWindow ((Nlm_GraphiC) d);
  2479.   Nlm_SetWindowCharDisplay (w, d);
  2480. }
  2481.  
  2482. static Nlm_SlatE Nlm_CommonSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2483.                                   Nlm_Int2 height, Nlm_Boolean border,
  2484.                                   Nlm_Boolean vScroll, Nlm_Boolean hScroll,
  2485.                                   Nlm_SltScrlProc vscrl, Nlm_SltScrlProc hscrl,
  2486.                                   Nlm_Int2 extra, Nlm_GphPrcsPtr classPtr)
  2487.  
  2488. {
  2489.   Nlm_GraphicData  gdata;
  2490.   Nlm_PoinT        npt;
  2491.   Nlm_RecT         r;
  2492.   Nlm_SlatE        s;
  2493.   Nlm_WindoW       tempPort;
  2494.  
  2495.   s = NULL;
  2496.   if (prnt != NULL) {
  2497.     tempPort = Nlm_SavePort ((Nlm_GraphiC) prnt);
  2498.     Nlm_GetNextPosition ((Nlm_GraphiC) prnt, &npt);
  2499.     Nlm_SelectFont (Nlm_systemFont);
  2500.     Nlm_LoadRect (&r, npt.x, npt.y, npt.x+width, npt.y+height);
  2501.     s = (Nlm_SlatE) Nlm_CreateLink ((Nlm_GraphiC) prnt, &r, sizeof (Nlm_SlateRec) + extra, classPtr);
  2502.     if (s != NULL) {
  2503.       if (classPtr != NULL) {
  2504.         classPtr->ancestor = slateProcs;
  2505.       } else {
  2506.         Nlm_GetGraphicData ((Nlm_GraphiC) s, &gdata);
  2507.         gdata.classptr = slateProcs;
  2508.         Nlm_SetGraphicData ((Nlm_GraphiC) s, &gdata);
  2509.       }
  2510.       Nlm_NewSlate (s, border, vScroll, hScroll, vscrl, hscrl, extra);
  2511.       if (vScroll) {
  2512.         r.right += Nlm_vScrollBarWidth;
  2513.       }
  2514.       Nlm_DoAdjustPrnt ((Nlm_GraphiC) s, &r, TRUE, FALSE);
  2515.       Nlm_DoShow ((Nlm_GraphiC) s, TRUE, FALSE);
  2516.     }
  2517.     Nlm_RestorePort (tempPort);
  2518.   }
  2519.   return s;
  2520. }
  2521.  
  2522. extern Nlm_SlatE Nlm_GeneralSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2523.                                    Nlm_Int2 height, Nlm_SltScrlProc scrl,
  2524.                                    Nlm_Int2 extra, Nlm_GphPrcsPtr classPtr)
  2525.  
  2526. {
  2527.   Nlm_SlatE  s;
  2528.  
  2529.   s = Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2530.                        height*Nlm_stdLineHeight+8, TRUE,
  2531.                        TRUE, FALSE, scrl, NULL, extra, classPtr);
  2532.   return s;
  2533. }
  2534.  
  2535. extern Nlm_SlatE Nlm_ScrollSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2536.                                   Nlm_Int2 height)
  2537.  
  2538. {
  2539.   Nlm_SlatE  s;
  2540.  
  2541.   s = Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2542.                        height*Nlm_stdLineHeight+8, TRUE,
  2543.                        TRUE, FALSE, NULL, NULL, 0, NULL);
  2544.   return s;
  2545. }
  2546.  
  2547. extern Nlm_SlatE Nlm_NormalSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2548.                                   Nlm_Int2 height)
  2549.  
  2550. {
  2551.   Nlm_SlatE  s;
  2552.  
  2553.   s = Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2554.                        height*Nlm_stdLineHeight+8, TRUE,
  2555.                        FALSE, FALSE, NULL, NULL, 0, NULL);
  2556.   return s;
  2557. }
  2558.  
  2559. extern Nlm_SlatE Nlm_HiddenSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2560.                                   Nlm_Int2 height)
  2561.  
  2562. {
  2563.   Nlm_SlatE  s;
  2564.  
  2565.   s = Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2566.                        height*Nlm_stdLineHeight+8, FALSE,
  2567.                        FALSE, FALSE, NULL, NULL, 0, NULL);
  2568.   return s;
  2569. }
  2570.  
  2571. extern void Nlm_VirtualSlate (Nlm_SlatE s, Nlm_Int2 before,
  2572.                               Nlm_Int2 after, Nlm_SltScrlProc actn)
  2573.  
  2574. {
  2575.   Nlm_Handle     chdl;
  2576.   Nlm_Handle     rhdl;
  2577.   Nlm_BaR        sb;
  2578.   Nlm_SlateData  sdata;
  2579.  
  2580.   Nlm_GetSlateData (s, &sdata);
  2581.   rhdl = sdata.rowHandles;
  2582.   if (rhdl != NULL) {
  2583.     Nlm_HandFree (rhdl);
  2584.   }
  2585.   chdl = sdata.colHandles;
  2586.   if (chdl != NULL) {
  2587.     Nlm_HandFree (chdl);
  2588.   }
  2589.   sdata.rowHandles = NULL;
  2590.   sdata.colHandles = NULL;
  2591.   sdata.numRows = 0;
  2592.   sdata.numCols = 0;
  2593.   sdata.barRows = 0;
  2594.   sdata.vBefore = before;
  2595.   sdata.vAfter = after;
  2596.   sdata.vAction = actn;
  2597.   Nlm_SetSlateData (s, &sdata);
  2598.   sb = sdata.hScrollBar;
  2599.   if (sb != NULL) {
  2600.     Nlm_DoReset ((Nlm_GraphiC) sb, TRUE);
  2601.   }
  2602.   sb = sdata.vScrollBar;
  2603.   if (sb != NULL) {
  2604.     Nlm_DoReset ((Nlm_GraphiC) sb, TRUE);
  2605.   }
  2606. }
  2607.  
  2608. extern void Nlm_RegisterRow (Nlm_SlatE s, Nlm_Int2 position,
  2609.                              Nlm_Int2 height, Nlm_Int2 count)
  2610.  
  2611. {
  2612.   Nlm_Boolean    added;
  2613.   Nlm_Int2       after;
  2614.   Nlm_Int2       barmax;
  2615.   Nlm_Int2       before;
  2616.   Nlm_Int2       chunk;
  2617.   Nlm_Int2       numRows;
  2618.   Nlm_Int2       delta;
  2619.   Nlm_Int2       i;
  2620.   Nlm_OfsPtr     optr;
  2621.   Nlm_RecT       r;
  2622.   Nlm_Handle     rhdl;
  2623.   Nlm_BaR        sb;
  2624.   Nlm_SlateData  sdata;
  2625.   Nlm_WindoW     tempPort;
  2626.   Nlm_Int2       vis;
  2627.  
  2628.   if (s != NULL) {
  2629.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2630.     Nlm_InsetRect (&r, 4, 4);
  2631.     Nlm_GetSlateData (s, &sdata);
  2632.     numRows = sdata.numRows;
  2633.     rhdl = sdata.rowHandles;
  2634.     added = FALSE;
  2635.     chunk = 128;
  2636.     delta = position - r.top;
  2637.     if (rhdl == NULL) {
  2638.       numRows = 1;
  2639.       rhdl = Nlm_HandNew (sizeof (Nlm_OffsetRec) * chunk);
  2640.       if (rhdl != NULL) {
  2641.         optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  2642.         optr [numRows - 1].offset = delta;
  2643.         optr [numRows - 1].height = height;
  2644.         added = TRUE;
  2645.         Nlm_HandUnlock (rhdl);
  2646.       }
  2647.       delta += height;
  2648.       count--;
  2649.     }
  2650.     if (rhdl != NULL && count > 0) {
  2651.       optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  2652.       for (i = 0; i < count; i++) {
  2653.         if (delta >= optr [numRows - 1].offset + optr [numRows - 1].height) {
  2654.           if (numRows % chunk == 0) {
  2655.             Nlm_HandUnlock (rhdl);
  2656.             rhdl = Nlm_HandMore (rhdl, sizeof (Nlm_OffsetRec) *
  2657.                                  (numRows / chunk + 1) * chunk);
  2658.             optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  2659.           }
  2660.           numRows++;
  2661.           optr [numRows - 1].offset = delta;
  2662.           optr [numRows - 1].height = height;
  2663.           added = TRUE;
  2664.         } else if (delta == optr [numRows - 1].offset &&
  2665.                    height > optr [numRows - 1].height) {
  2666.           optr [numRows - 1].height = height;
  2667.           added = TRUE;
  2668.         }
  2669.         delta += height;
  2670.       }
  2671.       Nlm_HandUnlock (rhdl);
  2672.     }
  2673.     sdata.numRows = numRows;
  2674.     sdata.rowHandles = rhdl;
  2675.     Nlm_SetSlateData (s, &sdata);
  2676.     if (added) {
  2677.       optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  2678.       if (numRows > 1) {
  2679.         i = numRows - 2;
  2680.         vis = 0;
  2681.         while (i >= 0 && optr [numRows - 1].offset + optr [numRows - 1].height -
  2682.                optr [i].offset <= r.bottom - r.top) {
  2683.           i--;
  2684.           vis++;
  2685.         }
  2686.         barmax = numRows - vis - 1;
  2687.       } else {
  2688.         barmax = 0;
  2689.       }
  2690.       sdata.barRows = barmax;
  2691.       Nlm_SetSlateData (s, &sdata);
  2692.       i = 1;
  2693.       vis = 0;
  2694.       while (i < numRows && optr [i].offset + optr [i].height -
  2695.              optr [0].offset <= r.bottom - r.top) {
  2696.         i++;
  2697.         vis++;
  2698.       }
  2699.       Nlm_HandUnlock (rhdl);
  2700.       sb = sdata.vScrollBar;
  2701.       if (sb != NULL) {
  2702.         before = sdata.vBefore;
  2703.         after = sdata.vAfter;
  2704.         tempPort = Nlm_SavePort ((Nlm_GraphiC) s);
  2705.         Nlm_DoSetRange ((Nlm_GraphiC) sb, 1, vis, barmax + before + after, FALSE);
  2706.         if (before > 0) {
  2707.           Nlm_DoSetValue ((Nlm_GraphiC) sb, before, FALSE);
  2708.         }
  2709.         Nlm_RestorePort (tempPort);
  2710.       }
  2711.     }
  2712.   }
  2713. }
  2714.  
  2715. extern void Nlm_RegisterColumn (Nlm_SlatE s, Nlm_Int2 position,
  2716.                                 Nlm_Int2 width, Nlm_Int2 count)
  2717.  
  2718. {
  2719. }
  2720.  
  2721. extern void Nlm_SetPanelClick (Nlm_PaneL p, Nlm_PnlClckProc click,
  2722.                                Nlm_PnlClckProc drag, Nlm_PnlClckProc hold,
  2723.                                Nlm_PnlClckProc release)
  2724.  
  2725. {
  2726.   Nlm_PanelData  pdata;
  2727.  
  2728.   if (p != NULL) {
  2729.     Nlm_GetPanelData (p, &pdata);
  2730.     pdata.click = click;
  2731.     pdata.drag = drag;
  2732.     pdata.hold = hold;
  2733.     pdata.release = release;
  2734.     Nlm_SetPanelData (p, &pdata);
  2735.   }
  2736. }
  2737.  
  2738. extern Nlm_PaneL Nlm_GeneralPanel (Nlm_SlatE s, Nlm_PnlActnProc draw,
  2739.                                    Nlm_Int2 extra, Nlm_PnlActnProc reset,
  2740.                                    Nlm_GphPrcsPtr classPtr)
  2741.  
  2742. {
  2743.   Nlm_GraphicData  gdata;
  2744.   Nlm_PoinT        npt;
  2745.   Nlm_PaneL        p;
  2746.   Nlm_RecT         r;
  2747.   Nlm_WindoW       tempPort;
  2748.  
  2749.   p = NULL;
  2750.   if (s != NULL) {
  2751.     tempPort = Nlm_SavePort ((Nlm_GraphiC) s);
  2752.     Nlm_GetNextPosition ((Nlm_GraphiC) s, &npt);
  2753.     Nlm_SelectFont (Nlm_systemFont);
  2754.     Nlm_LoadRect (&r, npt.x, npt.y, npt.x, npt.y);
  2755.     p = (Nlm_PaneL) Nlm_CreateLink ((Nlm_GraphiC) s, &r, sizeof (Nlm_PanelRec) + extra, classPtr);
  2756.     if (p != NULL) {
  2757.       if (classPtr != NULL) {
  2758.         classPtr->ancestor = panelProcs;
  2759.       } else {
  2760.         Nlm_GetGraphicData ((Nlm_GraphiC) p, &gdata);
  2761.         gdata.classptr = panelProcs;
  2762.         Nlm_SetGraphicData ((Nlm_GraphiC) p, &gdata);
  2763.       }
  2764.       Nlm_NewPanel (p, draw, extra, reset);
  2765.       Nlm_DoAdjustPrnt ((Nlm_GraphiC) p, &r, TRUE, FALSE);
  2766.       Nlm_DoShow ((Nlm_GraphiC) p, TRUE, FALSE);
  2767.     }
  2768.     Nlm_RestorePort (tempPort);
  2769.   }
  2770.   return p;
  2771. }
  2772.  
  2773. extern Nlm_PaneL Nlm_CustomPanel (Nlm_SlatE s, Nlm_PnlActnProc draw,
  2774.                                   Nlm_Int2 extra, Nlm_PnlActnProc reset)
  2775.  
  2776. {
  2777.   return (Nlm_GeneralPanel (s, draw, extra, reset, NULL));
  2778. }
  2779.  
  2780. extern Nlm_PaneL Nlm_AutonomousPanel (Nlm_GrouP prnt, Nlm_Int2 pixwidth,
  2781.                                       Nlm_Int2 pixheight, Nlm_PnlActnProc draw,
  2782.                                       Nlm_SltScrlProc vscrl, Nlm_SltScrlProc hscrl,
  2783.                                       Nlm_Int2 extra, Nlm_PnlActnProc reset,
  2784.                                       Nlm_GphPrcsPtr classPtr)
  2785.  
  2786. /*
  2787. *  Note that an autonomous panel is really a combination of slate and
  2788. *  panel in one object, and thus uses the slateProcs class function.
  2789. */
  2790.  
  2791. {
  2792.   Nlm_Boolean      border;
  2793.   Nlm_GraphicData  gdata;
  2794.   Nlm_Boolean      hScroll;
  2795.   Nlm_PoinT        npt;
  2796.   Nlm_PaneL        p;
  2797.   Nlm_RecT         r;
  2798.   Nlm_WindoW       tempPort;
  2799.   Nlm_Boolean      vScroll;
  2800.  
  2801.  
  2802.   p = NULL;
  2803.   if (prnt != NULL) {
  2804.     tempPort = Nlm_SavePort ((Nlm_GraphiC) prnt);
  2805.     Nlm_GetNextPosition ((Nlm_GraphiC) prnt, &npt);
  2806.     Nlm_SelectFont (Nlm_systemFont);
  2807.     border = (Nlm_Boolean) (vscrl != NULL || hscrl != NULL);
  2808.     vScroll = (Nlm_Boolean) (vscrl != NULL);
  2809.     hScroll = (Nlm_Boolean) (hscrl != NULL);
  2810. #ifndef DCLAP
  2811.     /* dgg -- what the heck are these +8s for ?? */
  2812.     if (vScroll || hScroll) {
  2813.       Nlm_LoadRect (&r, npt.x, npt.y, npt.x+pixwidth+8, npt.y+pixheight+8);
  2814.     } else 
  2815. #endif
  2816.     {
  2817.       Nlm_LoadRect (&r, npt.x, npt.y, npt.x+pixwidth, npt.y+pixheight);
  2818.     }
  2819.     p = (Nlm_PaneL) Nlm_CreateLink ((Nlm_GraphiC) prnt, &r, sizeof (Nlm_PanelRec) + extra, classPtr);
  2820.     if (p != NULL) {
  2821.       if (classPtr != NULL) {
  2822.         classPtr->ancestor = slateProcs;
  2823.       } else {
  2824.         Nlm_GetGraphicData ((Nlm_GraphiC) p, &gdata);
  2825.         gdata.classptr = slateProcs;
  2826.         Nlm_SetGraphicData ((Nlm_GraphiC) p, &gdata);
  2827.       }
  2828.       Nlm_NewSlate ((Nlm_SlatE) p, border, vScroll, hScroll, vscrl, hscrl, extra);
  2829.       Nlm_NewPanel (p, draw, extra, reset);
  2830.       if (vScroll) {
  2831.         r.right += Nlm_vScrollBarWidth;
  2832.       }
  2833.       if (hScroll) {
  2834.         r.bottom += Nlm_hScrollBarHeight;
  2835.       }
  2836.       Nlm_DoAdjustPrnt ((Nlm_GraphiC) p, &r, TRUE, FALSE);
  2837.       Nlm_DoShow ((Nlm_GraphiC) p, TRUE, FALSE);
  2838.     }
  2839.     Nlm_RestorePort (tempPort);
  2840.   }
  2841.   return p;
  2842. }
  2843.  
  2844. extern Nlm_PaneL Nlm_SimplePanel (Nlm_GrouP prnt, Nlm_Int2 pixwidth,
  2845.                                   Nlm_Int2 pixheight, Nlm_PnlActnProc draw)
  2846.  
  2847. {
  2848.   Nlm_PaneL  p;
  2849.  
  2850.   p = Nlm_AutonomousPanel (prnt, pixwidth, pixheight, draw, NULL, NULL, 0, NULL, NULL);
  2851.   return p;
  2852. }
  2853.  
  2854. extern void Nlm_RegisterRect (Nlm_PaneL p, Nlm_RectPtr r)
  2855.  
  2856. {
  2857.   Nlm_BoxData  bdata;
  2858.   Nlm_RecT     pr;
  2859.  
  2860.   if (p != NULL && r != NULL) {
  2861.     Nlm_RecordRect ((Nlm_GraphiC) p, r);
  2862.     Nlm_NextPosition ((Nlm_GraphiC) p, r);
  2863.     Nlm_GetRect ((Nlm_GraphiC) p, &pr);
  2864.     Nlm_GetBoxData ((Nlm_BoX) p, &bdata);
  2865.     pr.right = bdata.limitPoint.x;
  2866.     pr.bottom = bdata.limitPoint.y;
  2867.     Nlm_SetRect ((Nlm_GraphiC) p, &pr);
  2868.     Nlm_DoAdjustPrnt ((Nlm_GraphiC) p, r, TRUE, TRUE);
  2869.   }
  2870. }
  2871.  
  2872. static Nlm_DisplaY Nlm_CommonDisplay (Nlm_GrouP prnt, Nlm_Int2 width,
  2873.                                       Nlm_Int2 height, Nlm_Boolean hidden,
  2874.                                       Nlm_Boolean scroll)
  2875.  
  2876. {
  2877.   Nlm_DisplaY  d;
  2878.   Nlm_WindoW   tempPort;
  2879.  
  2880.   d = NULL;
  2881.   if (prnt != NULL) {
  2882.     tempPort = Nlm_SavePort ((Nlm_GraphiC) prnt);
  2883.     dispfont = Nlm_programFont;
  2884.     Nlm_SelectFont (dispfont);
  2885.     disphght = Nlm_LineHeight ();
  2886.     if (hidden) {
  2887.       d = (Nlm_DisplaY) Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2888.                                          height*Nlm_stdLineHeight+8, FALSE,
  2889.                                          FALSE, FALSE, NULL, NULL,
  2890.                                          sizeof (Nlm_DisplayData), displayProcs);
  2891.     } else if (scroll) {
  2892.       d = (Nlm_DisplaY) Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2893.                                          height*Nlm_stdLineHeight+8, TRUE,
  2894.                                          TRUE, FALSE, NULL, NULL,
  2895.                                          sizeof (Nlm_DisplayData), displayProcs);
  2896.     } else {
  2897.       d = (Nlm_DisplaY) Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2898.                                          height*Nlm_stdLineHeight+8, TRUE,
  2899.                                          FALSE, FALSE, NULL, NULL,
  2900.                                          sizeof (Nlm_DisplayData), displayProcs);
  2901.     }
  2902.     if (d != NULL) {
  2903.       Nlm_NewDisplay (d);
  2904.     }
  2905.     Nlm_SelectFont (Nlm_systemFont);
  2906.     Nlm_RestorePort (tempPort);
  2907.   }
  2908.   return d;
  2909. }
  2910.  
  2911. extern Nlm_DisplaY Nlm_NormalDisplay (Nlm_GrouP prnt, Nlm_Int2 width,
  2912.                                       Nlm_Int2 height)
  2913.  
  2914. {
  2915.   return (Nlm_CommonDisplay (prnt, width, height, FALSE, FALSE));
  2916. }
  2917.  
  2918. extern Nlm_DisplaY Nlm_ScrollDisplay (Nlm_GrouP prnt, Nlm_Int2 width,
  2919.                                       Nlm_Int2 height)
  2920.  
  2921. {
  2922.   return (Nlm_CommonDisplay (prnt, width, height, FALSE, TRUE));
  2923. }
  2924.  
  2925. extern void Nlm_CaptureSlateFocus (Nlm_SlatE s)
  2926.  
  2927. {
  2928.   Nlm_WindoW     w;
  2929. #ifdef WIN_MSWIN
  2930.   Nlm_SlateTool  h;
  2931. #endif
  2932. #ifdef WIN_MOTIF
  2933.   Nlm_SlateTool  h;
  2934. #endif
  2935.  
  2936.   w = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  2937.   Nlm_DoLoseFocus ((Nlm_GraphiC) w, (Nlm_GraphiC) s, FALSE);
  2938.   Nlm_ChangeSlateFocus (s, TRUE);
  2939. #ifdef WIN_MSWIN
  2940.   h = Nlm_GetSlateHandle (s);
  2941.   if (h != NULL) {
  2942.     SetFocus (h);
  2943.   }
  2944. #endif
  2945. #ifdef WIN_MOTIF
  2946.   h = Nlm_GetSlateHandle (s);
  2947.   if (h != NULL) {
  2948.     XmProcessTraversal (h, XmTRAVERSE_CURRENT);
  2949.   }
  2950. #endif
  2951. }
  2952.  
  2953. static Nlm_GraphiC Nlm_SlateGainFocus (Nlm_GraphiC s, Nlm_Char ch, Nlm_Boolean savePort)
  2954.  
  2955. {
  2956.   Nlm_SltCharProc  keyProc;
  2957.   Nlm_GraphiC      rsult;
  2958.  
  2959.   rsult = NULL;
  2960.   keyProc = Nlm_GetSlateCharProc ((Nlm_SlatE) s);
  2961.   if (keyProc != NULL) {
  2962.     Nlm_ChangeSlateFocus ((Nlm_SlatE) s, TRUE);
  2963.     rsult = s;
  2964.   }
  2965.   return rsult;
  2966. }
  2967.  
  2968. static void Nlm_SlateLoseFocus (Nlm_GraphiC s, Nlm_GraphiC excpt, Nlm_Boolean savePort)
  2969.  
  2970. {
  2971.   if (s != excpt) {
  2972.     Nlm_ChangeSlateFocus ((Nlm_SlatE) s, FALSE);
  2973.   }
  2974. }
  2975.  
  2976. #ifdef WIN_MAC
  2977. extern Nlm_Boolean Nlm_RegisterSlates (void)
  2978.  
  2979. {
  2980.   return TRUE;
  2981. }
  2982. #endif
  2983.  
  2984. #ifdef WIN_MSWIN
  2985. static void Nlm_DrawSlate (Nlm_SlatE s)
  2986.  
  2987. {
  2988.   Nlm_PnlActnProc  drw;
  2989.   Nlm_SlateTool    h;
  2990.   Nlm_PaneL        n;
  2991.   Nlm_PaneL        p;
  2992.   Nlm_PanelData    pdata;
  2993.   Nlm_RecT         r;
  2994.  
  2995.   if (Nlm_GetVisible ((Nlm_GraphiC) s) && Nlm_GetAllParentsVisible ((Nlm_GraphiC) s)) {
  2996.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  2997.     if (h != NULL && IsWindowVisible (h)) {
  2998.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2999.       Nlm_SelectFont (Nlm_systemFont);
  3000.       Nlm_ResetDrawingTools ();
  3001.             Nlm_DrawSlateBorder( s);
  3002.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  3003.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  3004.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  3005.         p = (Nlm_PaneL) s;
  3006. /*
  3007.         recentlyClickedPanel = p;
  3008. */
  3009.         drw = Nlm_GetPanelDraw (p);
  3010.         if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  3011.           drw (p);
  3012.           Nlm_ResetDrawingTools ();
  3013.         }
  3014.       } else {
  3015.         p = (Nlm_PaneL) Nlm_GetChild ((Nlm_GraphiC) s);
  3016.         while (p != NULL) {
  3017.           n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  3018.           drw = Nlm_GetPanelDraw (p);
  3019.           if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  3020.             drw (p);
  3021.             Nlm_ResetDrawingTools ();
  3022.           }
  3023.           p = n;
  3024.         }
  3025.       }
  3026.     }
  3027.   }
  3028. }
  3029.  
  3030. /* Message cracker functions */
  3031.  
  3032. static void MyCls_OnLButtonDown (HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
  3033.  
  3034. {
  3035.   Nlm_PnlClckProc  clk;
  3036.   Nlm_SlateTool    h;
  3037.   Nlm_Int2         hOffset;
  3038.   Nlm_PaneL        n;
  3039.   Nlm_Boolean      notInside;
  3040.   Nlm_PaneL        p;
  3041.   Nlm_PanelData    pdata;
  3042.   Nlm_PoinT        pt;
  3043.   Nlm_RecT         r;
  3044.   Nlm_SlatE        s;
  3045.   Nlm_Int2         vOffset;
  3046.  
  3047.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3048.   h = Nlm_GetSlateHandle (s);
  3049.   Nlm_ctrlKey = (Nlm_Boolean) ((MK_CONTROL & keyFlags) != 0);
  3050.   Nlm_shftKey = (Nlm_Boolean) ((MK_SHIFT & keyFlags) != 0);
  3051.   SetCapture (hwnd);
  3052.   currentSlate = s;
  3053.   Nlm_dblClick = fDoubleClick;
  3054.   if (Nlm_GetEnabled ((Nlm_GraphiC) s) && Nlm_GetVisible ((Nlm_GraphiC) s)) {
  3055.     SetTimer (h, 2, 100, NULL);
  3056.     slateTimerUsed = TRUE;
  3057.     slateTimer = h;
  3058.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  3059.     Nlm_LoadPt (&pt, (Nlm_Int2) x + r.left, (Nlm_Int2) y + r.top);
  3060.     recentlyClickedSlate = (Nlm_SlatE) s;
  3061.     recentlyClickedPanel = NULL;
  3062.     Nlm_SelectFont (Nlm_systemFont);
  3063.     Nlm_ResetDrawingTools ();
  3064.     Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  3065.     if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  3066.         pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  3067.       p = (Nlm_PaneL) s;
  3068.       recentlyClickedPanel = p;
  3069.       clk = Nlm_GetPanelClick (p);
  3070.       if (clk != NULL && Nlm_GetEnabled ((Nlm_GraphiC) p) && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  3071.         clk (p, pt);
  3072.         Nlm_Update ();
  3073.       }
  3074.     } else {
  3075.       p = Nlm_CreateReverseLinks ((Nlm_SlatE) s);
  3076.       notInside = TRUE;
  3077.       while (p != NULL && notInside) {
  3078.         n = Nlm_GetPanelPrev (p);
  3079.         Nlm_GetPanelData (p, &pdata);
  3080.         if (pdata.click != NULL || pdata.drag != NULL ||
  3081.             pdata.hold != NULL || pdata.release != NULL) {
  3082.           Nlm_GetRect ((Nlm_GraphiC) p, &r);
  3083.           Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  3084.           Nlm_OffsetRect (&r, -hOffset, -vOffset);
  3085.           if (Nlm_PtInRect (pt, &r) && Nlm_GetEnabled ((Nlm_GraphiC) p) &&
  3086.               Nlm_GetVisible ((Nlm_GraphiC) p)) {
  3087.             recentlyClickedPanel = p;
  3088.             notInside = FALSE;
  3089.             clk = Nlm_GetPanelClick (p);
  3090.             if (clk != NULL) {
  3091.               clk (p, pt);
  3092.               Nlm_Update ();
  3093.             }
  3094.           }
  3095.         }
  3096.         p = n;
  3097.       }
  3098.     }
  3099.   }
  3100. }
  3101.  
  3102. static void MyCls_OnMouseMove (HWND hwnd, int x, int y, UINT keyFlags)
  3103.  
  3104. {
  3105.   Nlm_PnlClckProc  drg;
  3106.   Nlm_PaneL        p;
  3107.   Nlm_PoinT        pt;
  3108.   Nlm_RecT         r;
  3109.   Nlm_SlatE        s;
  3110.  
  3111.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3112.   if (currentSlate == s) {
  3113.     if (Nlm_GetEnabled ((Nlm_GraphiC) s) &&
  3114.         Nlm_GetVisible ((Nlm_GraphiC) s)) {
  3115.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  3116.       Nlm_LoadPt (&pt, (Nlm_Int2) x + r.left, (Nlm_Int2) y + r.top);
  3117.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  3118.         p = recentlyClickedPanel;
  3119.         drg = Nlm_GetPanelDrag (p);
  3120.         if (drg != NULL) {
  3121.           Nlm_ResetDrawingTools ();
  3122.           drg (p, pt);
  3123.         }
  3124.       }
  3125.     }
  3126.   }
  3127. }
  3128.  
  3129. static void MyCls_OnLButtonUp (HWND hwnd, int x, int y, UINT keyFlags)
  3130.  
  3131. {
  3132.   Nlm_SlateTool    h;
  3133.   Nlm_PaneL        p;
  3134.   Nlm_PoinT        pt;
  3135.   Nlm_RecT         r;
  3136.   Nlm_PnlClckProc  rls;
  3137.   Nlm_SlatE        s;
  3138.  
  3139.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3140.   ReleaseCapture ();
  3141.   h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  3142.   if (slateTimerUsed) {
  3143.     KillTimer (h, 2);
  3144.     slateTimer = NULL;
  3145.   }
  3146.   slateTimerUsed = FALSE;
  3147.   if (currentSlate == s) {
  3148.     if (Nlm_GetEnabled ((Nlm_GraphiC) s) &&
  3149.         Nlm_GetVisible ((Nlm_GraphiC) s)) {
  3150.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  3151.       Nlm_LoadPt (&pt, (Nlm_Int2) x + r.left, (Nlm_Int2) y + r.top);
  3152.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  3153.         p = recentlyClickedPanel;
  3154.         rls = Nlm_GetPanelRelease (p);
  3155.         if (rls != NULL) {
  3156.           Nlm_ResetDrawingTools ();
  3157.           rls (p, pt);
  3158.         }
  3159.       }
  3160.       Nlm_SelectFont (Nlm_systemFont);
  3161.       Nlm_ResetDrawingTools ();
  3162.       recentlyClickedSlate = NULL;
  3163.       recentlyClickedPanel = NULL;
  3164.     }
  3165.   }
  3166.   currentSlate = NULL;
  3167. }
  3168.  
  3169. static void MyCls_OnTimer (HWND hwnd, UINT id)
  3170.  
  3171. {
  3172.   Nlm_PaneL        p;
  3173.   Nlm_PnlClckProc  prs;
  3174.   Nlm_PoinT        pt;
  3175.   Nlm_SlatE        s;
  3176.  
  3177.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3178.   if (currentSlate == s) {
  3179.     if (Nlm_GetEnabled ((Nlm_GraphiC) s) && Nlm_GetVisible ((Nlm_GraphiC) s)) {
  3180.       Nlm_MousePosition (&pt);
  3181.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  3182.         p = recentlyClickedPanel;
  3183.         prs = Nlm_GetPanelHold (p);
  3184.         if (prs != NULL) {
  3185.           Nlm_ResetDrawingTools ();
  3186.           prs (p, pt);
  3187.         }
  3188.       }
  3189.     }
  3190.   }
  3191. }
  3192.  
  3193. static void MyCls_OnPaint (HWND hwnd)
  3194.  
  3195. {
  3196.   PAINTSTRUCT    ps;
  3197.   Nlm_PointTool  ptool;
  3198.   Nlm_RectTool   rtool;
  3199.   Nlm_SlatE      s;
  3200.   Nlm_PortTool   temp;
  3201.  
  3202.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3203.   temp = Nlm_currentHDC;
  3204.   GetUpdateRgn (hwnd, (Nlm_RgnTool) Nlm_updateRgn, TRUE);
  3205.   GetWindowRect (hwnd, &rtool);
  3206.   ptool = * (PPOINT) &rtool.left;
  3207.   ScreenToClient (Nlm_currentHWnd, &ptool);
  3208.   Nlm_OffsetRgn (Nlm_updateRgn, (Nlm_Int2) ptool.x, (Nlm_Int2) ptool.y);
  3209.   BeginPaint (hwnd, &ps);
  3210.   Nlm_currentHDC = Nlm_ParentWindowPort ((Nlm_GraphiC) s);
  3211.   SelectClipRgn (Nlm_currentHDC, (Nlm_RgnTool) Nlm_updateRgn);
  3212.   GetRgnBox ((Nlm_RgnTool) Nlm_updateRgn, &rtool);
  3213.   Nlm_RectToolToRecT (&rtool, &Nlm_updateRect);
  3214.   Nlm_DrawSlate (s);
  3215.   EndPaint (hwnd, &ps);
  3216.   GetWindowRect (Nlm_currentHWnd, &rtool);
  3217.   ptool = * (PPOINT) &rtool.left;
  3218.   SetRectRgn ((Nlm_RgnTool) Nlm_updateRgn, rtool.left,
  3219.               rtool.top, rtool.right, rtool.bottom);
  3220.   Nlm_OffsetRgn (Nlm_updateRgn, (Nlm_Int2) (-ptool.x), (Nlm_Int2) (-ptool.y));
  3221.   SelectClipRgn (Nlm_currentHDC, NULL);
  3222.   GetRgnBox ((Nlm_RgnTool) Nlm_updateRgn, &rtool);
  3223.   Nlm_RectToolToRecT (&rtool, &Nlm_updateRect);
  3224.   Nlm_currentHDC = temp;
  3225. }
  3226.  
  3227. static void MyCls_OnChar (HWND hwnd, UINT ch, int cRepeat)
  3228.  
  3229. {
  3230.   Nlm_SltCharProc  keyProc;
  3231.   Nlm_SlatE        s;
  3232.  
  3233.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3234.   keyProc = Nlm_GetSlateCharProc (s);
  3235.   handlechar = FALSE;
  3236.   if (keyProc != NULL) {
  3237.     keyProc (s, (Nlm_Char) ch);
  3238.   } else if (ch == '\t') {
  3239.     Nlm_DoSendFocus ((Nlm_GraphiC) s, (Nlm_Char) ch);
  3240.   } else if (ch == '\n' || ch == '\r') {
  3241.     Nlm_DoSendFocus ((Nlm_GraphiC) s, (Nlm_Char) ch);
  3242.   } else {
  3243.     handlechar = TRUE;
  3244.   }
  3245. }
  3246.  
  3247. static void MyCls_OnSetFocus (HWND hwnd, HWND hwndOldFocus)
  3248.  
  3249. {
  3250.   Nlm_SlatE  s;
  3251.  
  3252.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3253.   Nlm_ChangeSlateFocus (s, TRUE);
  3254. }
  3255.  
  3256. static void MyCls_OnKillFocus (HWND hwnd, HWND hwndNewFocus)
  3257.  
  3258. {
  3259.   Nlm_SlatE  s;
  3260.  
  3261.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3262.   Nlm_ChangeSlateFocus (s, FALSE);
  3263. }
  3264.  
  3265. LRESULT CALLBACK EXPORT SlateProc (HWND hwnd, UINT message,
  3266.                                    WPARAM wParam, LPARAM lParam)
  3267.  
  3268. {
  3269.   LRESULT      rsult;
  3270.   Nlm_SlatE    s;
  3271.   HDC          tempHDC;
  3272.   HWND         tempHWnd;
  3273.   Nlm_Boolean  clearRecent;  /* dgg */
  3274.  
  3275.   if (Nlm_VibrantDisabled ()) {
  3276.     return DefWindowProc (hwnd, message, wParam, lParam);
  3277.   }
  3278.  
  3279.   rsult = 0;
  3280.   clearRecent = FALSE;
  3281.   tempHWnd = Nlm_currentHWnd;
  3282.   tempHDC = Nlm_currentHDC;
  3283.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3284.   Nlm_theWindow = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  3285.   Nlm_currentHWnd = GetParent (hwnd);
  3286.   Nlm_currentHDC = Nlm_ParentWindowPort ((Nlm_GraphiC) s);
  3287.   Nlm_currentWindowTool = hwnd;
  3288.   Nlm_currentKey = '\0';
  3289.   Nlm_currentWParam = wParam;
  3290.   Nlm_currentLParam = lParam;
  3291.   Nlm_cmmdKey = FALSE;
  3292.   Nlm_ctrlKey = FALSE;
  3293.   Nlm_optKey = FALSE;
  3294.   Nlm_shftKey = FALSE;
  3295.   Nlm_dblClick = FALSE;
  3296.   switch (message) {
  3297.     case WM_LBUTTONDBLCLK:
  3298.       HANDLE_WM_LBUTTONDBLCLK (hwnd, wParam, lParam, MyCls_OnLButtonDown);
  3299.       break;
  3300.     case WM_LBUTTONDOWN:
  3301.       HANDLE_WM_LBUTTONDOWN (hwnd, wParam, lParam, MyCls_OnLButtonDown);
  3302.       break;
  3303.     case WM_MOUSEMOVE:
  3304.       HANDLE_WM_MOUSEMOVE (hwnd, wParam, lParam, MyCls_OnMouseMove);
  3305.       break;
  3306.     case WM_TIMER:
  3307.       HANDLE_WM_TIMER (hwnd, wParam, lParam, MyCls_OnTimer);
  3308.       break;
  3309.     case WM_LBUTTONUP:
  3310.       HANDLE_WM_LBUTTONUP (hwnd, wParam, lParam, MyCls_OnLButtonUp);
  3311. #ifdef DCLAP
  3312.       clearRecent = TRUE;
  3313. #endif
  3314.       break;
  3315.     case WM_PAINT:
  3316.       HANDLE_WM_PAINT (hwnd, wParam, lParam, MyCls_OnPaint);
  3317.       break;
  3318.     case WM_CHAR:
  3319.       HANDLE_WM_CHAR (hwnd, wParam, lParam, MyCls_OnChar);
  3320.       if (handlechar) {
  3321.         rsult = DefWindowProc (hwnd, message, wParam, lParam);
  3322.       }
  3323.       break;
  3324.     case WM_SETFOCUS:
  3325.       HANDLE_WM_SETFOCUS (hwnd, wParam, lParam, MyCls_OnSetFocus);
  3326.       rsult = DefWindowProc (hwnd, message, wParam, lParam);
  3327.       break;
  3328.     case WM_KILLFOCUS:
  3329.       HANDLE_WM_KILLFOCUS (hwnd, wParam, lParam, MyCls_OnKillFocus);
  3330.       rsult = DefWindowProc (hwnd, message, wParam, lParam);
  3331.       break;
  3332.     default:
  3333.       rsult = DefWindowProc (hwnd, message, wParam, lParam);
  3334. #ifdef DCLAP
  3335.       /* clearRecent = TRUE; << bad, calls here for DRAG message !? */
  3336. #endif
  3337.       break;
  3338.   }
  3339.  
  3340. /* jk modification of dgg addition -- clear problems w/ drag message appearing after mouseup */
  3341.   if (clearRecent) {
  3342.     recentlyClickedSlate = NULL;
  3343.     recentlyClickedPanel = NULL;
  3344.   }
  3345.  
  3346.   Nlm_currentHWnd = tempHWnd;
  3347.   Nlm_currentHDC = tempHDC;
  3348.   Nlm_currentWindowTool = tempHWnd;
  3349.   return rsult;
  3350. }
  3351.  
  3352. extern Nlm_Boolean Nlm_RegisterSlates (void)
  3353.  
  3354. {
  3355.   Nlm_Boolean  rsult;
  3356.   WNDCLASS     wc;
  3357.  
  3358.   rsult = FALSE;
  3359.   wc.style = CS_PARENTDC | CS_DBLCLKS;
  3360.   wc.lpfnWndProc = SlateProc;
  3361.   wc.cbClsExtra = 0;
  3362.   wc.cbWndExtra = 0;
  3363.   wc.hInstance = Nlm_currentHInst;
  3364.   wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  3365.   wc.hCursor = LoadCursor (NULL, IDC_ARROW);
  3366.   wc.hbrBackground = GetStockObject (HOLLOW_BRUSH);
  3367.   wc.lpszMenuName = NULL;
  3368.   sprintf (slateclass, "Nlm_SlateClass%ld", (long) (int) Nlm_currentHInst);
  3369.   wc.lpszClassName = slateclass;
  3370.   rsult = (Nlm_Boolean) RegisterClass (&wc);
  3371.   return rsult;
  3372. }
  3373. #endif
  3374.  
  3375. #ifdef WIN_MOTIF
  3376. extern Nlm_Boolean Nlm_RegisterSlates (void)
  3377.  
  3378. {
  3379.   XtActionsRec  actions;
  3380.  
  3381.   actions.string = "slate";
  3382.   actions.proc = Nlm_SlateClickCallback;
  3383.   XtAppAddActions (Nlm_appContext, &actions, 1);
  3384.   actions.string = "piano";
  3385.   actions.proc = Nlm_SlateKeyCallback;
  3386.   XtAppAddActions (Nlm_appContext, &actions, 1);
  3387.   return TRUE;
  3388. }
  3389. #endif
  3390.  
  3391. extern void Nlm_KillSlateTimer (void)
  3392.  
  3393. {
  3394.   recentlyClickedSlate = NULL;
  3395.   recentlyClickedPanel = NULL;
  3396. #ifdef WIN_MAC
  3397. #endif
  3398. #ifdef WIN_MSWIN
  3399.   if (slateTimerUsed) {
  3400.     KillTimer (slateTimer, 2);
  3401.     slateTimer = NULL;
  3402.   }
  3403.   slateTimerUsed = FALSE;
  3404. #endif
  3405. #ifdef WIN_MOTIF
  3406.   if (slateTimerUsed) {
  3407.     XtRemoveTimeOut (slateTimer);
  3408.     slateTimer = 0;
  3409.   }
  3410.   slateTimerUsed = FALSE;
  3411. #endif
  3412. }
  3413.  
  3414. extern void Nlm_FreeSlate (void)
  3415.  
  3416. {
  3417.   gphprcsptr = (Nlm_GphPrcsPtr) Nlm_MemFree (gphprcsptr);
  3418. }
  3419.  
  3420. extern void Nlm_InitSlate (void)
  3421.  
  3422. {
  3423.   gphprcsptr = (Nlm_GphPrcsPtr) Nlm_MemNew (sizeof (Nlm_GphPrcs) * 3);
  3424.  
  3425.   slateProcs = &(gphprcsptr [0]);
  3426. #ifdef WIN_MAC
  3427.   slateProcs->click = Nlm_SlateClick;
  3428.   slateProcs->key = Nlm_SlateKey;
  3429.   slateProcs->draw = Nlm_DrawSlate;
  3430. #endif
  3431. #ifdef WIN_MSWIN
  3432.   slateProcs->command = Nlm_SlateCommand;
  3433. #endif
  3434. #ifdef WIN_MOTIF
  3435.   slateProcs->callback = Nlm_SlateCallback;
  3436. #endif
  3437.   slateProcs->show = Nlm_ShowSlate;
  3438.   slateProcs->hide = Nlm_HideSlate;
  3439.   slateProcs->enable = Nlm_EnableSlate;
  3440.   slateProcs->disable = Nlm_DisableSlate;
  3441.   slateProcs->remove = Nlm_RemoveSlate;
  3442.   slateProcs->reset = Nlm_ResetSlate;
  3443.   slateProcs->select = Nlm_SelectSlate;
  3444.   slateProcs->countItems = Nlm_CountGroupItems;
  3445.   slateProcs->linkIn = Nlm_LinkIn;
  3446.   slateProcs->adjustPrnt = Nlm_AdjustSlate;
  3447.   slateProcs->setOffset = Nlm_SetSlateOffset;
  3448.   slateProcs->getOffset = Nlm_GetSlateOffset;
  3449.   slateProcs->setPosition = Nlm_SetSlatePosition;
  3450.   slateProcs->getPosition = Nlm_GetSlatePosition;
  3451.   slateProcs->setRange = Nlm_SetSlateRange;
  3452.   slateProcs->gainFocus = Nlm_SlateGainFocus;
  3453.   slateProcs->loseFocus = Nlm_SlateLoseFocus;
  3454.  
  3455.   panelProcs = &(gphprcsptr [1]);
  3456.   panelProcs->show = Nlm_ShowPanel;
  3457.   panelProcs->hide = Nlm_HidePanel;
  3458.   panelProcs->enable = Nlm_EnablePanel;
  3459.   panelProcs->disable = Nlm_DisablePanel;
  3460.   panelProcs->remove = Nlm_RemovePanel;
  3461.   panelProcs->reset = Nlm_ResetPanel;
  3462.   panelProcs->select = Nlm_SelectPanel;
  3463.   panelProcs->getOffset = Nlm_GetPanelOffset;
  3464.   panelProcs->setPosition = Nlm_SetPanelPosition;
  3465.   panelProcs->getPosition = Nlm_GetPanelPosition;
  3466.  
  3467.   displayProcs = &(gphprcsptr [2]);
  3468.   displayProcs->select = Nlm_SelectDisplay;
  3469.   displayProcs->sendChar = Nlm_PaintOrFormatChar;
  3470. }
  3471.